@modelprofile.com/browser-runtime 1.0.0

package/dist_ts/classes.egressproxy.js

@@ -0,0 +1,830 @@
+import * as plugins from './plugins.js';
+import { BrowserRuntimeError } from './errors.js';
+import { randomId, validateBoundedString, validateInteger, validateOptionalInteger, waitBounded, } from './utils.js';
+const hopByHopHeaders = new Set([
+    'connection',
+    'keep-alive',
+    'proxy-authenticate',
+    'proxy-authorization',
+    'proxy-connection',
+    'te',
+    'trailer',
+    'transfer-encoding',
+    'upgrade',
+]);
+export class BrowserEgressProxy {
+    projectId;
+    allowedPorts;
+    maxConnections;
+    maxActiveRequests;
+    maxHeaderBytes;
+    connectTimeoutMs;
+    idleTimeoutMs;
+    tunnelLifetimeMs;
+    requestTimeoutMs;
+    maxRequestBytes;
+    maxResponseBytes;
+    maxTunnelBytes;
+    resolver;
+    connector;
+    username = randomId(18);
+    password = randomId(32);
+    expectedAuthorization;
+    clientSockets = new Set();
+    upstreamSockets = new Set();
+    activeOperations = new Set();
+    server;
+    listenPort;
+    startPromise;
+    stopPromise;
+    lifecycleState = 'stopped';
+    lifecycleController = new AbortController();
+    ordinaryRequests = 0;
+    upgradeRequests = 0;
+    connectRequests = 0;
+    rejectedRequests = 0;
+    constructor(options) {
+        this.projectId = validateBoundedString(options.projectId, 'projectId', 1, 128);
+        const ports = options.allowedPorts ?? [80, 443];
+        if (!Array.isArray(ports) || ports.length < 1 || ports.length > 32) {
+            throw new BrowserRuntimeError('INVALID_INPUT', 'allowedPorts must contain 1 to 32 ports');
+        }
+        this.allowedPorts = new Set(ports.map((port) => validateInteger(port, 'allowedPort', 1, 65535)));
+        if (this.allowedPorts.size !== ports.length) {
+            throw new BrowserRuntimeError('INVALID_INPUT', 'allowedPorts must not contain duplicates');
+        }
+        this.maxConnections = validateOptionalInteger(options.maxConnections, 'maxConnections', 1, 1024, 128);
+        this.maxActiveRequests = validateOptionalInteger(options.maxActiveRequests, 'maxActiveRequests', 1, 1024, this.maxConnections);
+        this.maxHeaderBytes = validateOptionalInteger(options.maxHeaderBytes, 'maxHeaderBytes', 1024, 128 * 1024, 32 * 1024);
+        this.connectTimeoutMs = validateOptionalInteger(options.connectTimeoutMs, 'connectTimeoutMs', 100, 60_000, 10_000);
+        this.idleTimeoutMs = validateOptionalInteger(options.idleTimeoutMs, 'idleTimeoutMs', 1000, 10 * 60_000, 60_000);
+        this.tunnelLifetimeMs = validateOptionalInteger(options.tunnelLifetimeMs, 'tunnelLifetimeMs', 1000, 60 * 60_000, 10 * 60_000);
+        this.requestTimeoutMs = validateOptionalInteger(options.requestTimeoutMs, 'requestTimeoutMs', 1000, 60 * 60_000, Math.min(this.tunnelLifetimeMs, 5 * 60_000));
+        this.maxRequestBytes = validateOptionalInteger(options.maxRequestBytes, 'maxRequestBytes', 1024, 256 * 1024 * 1024, 16 * 1024 * 1024);
+        this.maxResponseBytes = validateOptionalInteger(options.maxResponseBytes, 'maxResponseBytes', 1024, 1024 * 1024 * 1024, 64 * 1024 * 1024);
+        this.maxTunnelBytes = validateOptionalInteger(options.maxTunnelBytes, 'maxTunnelBytes', 1024, 2 * 1024 * 1024 * 1024, 256 * 1024 * 1024);
+        this.resolver = options.resolver ?? (async (hostname, lookupOptions) => (plugins.dns.promises.lookup(hostname, {
+            all: lookupOptions.all,
+            verbatim: lookupOptions.verbatim,
+        })));
+        this.connector = options.connector ?? ((connectionOptions) => plugins.net.connect({
+            host: connectionOptions.address,
+            family: connectionOptions.family,
+            port: connectionOptions.port,
+        }));
+        this.expectedAuthorization = plugins.Buffer.from(`Basic ${plugins.Buffer.from(`${this.username}:${this.password}`, 'utf8').toString('base64')}`, 'utf8');
+    }
+    get credentials() {
+        return { username: this.username, password: this.password };
+    }
+    get port() {
+        if (this.listenPort === undefined)
+            throw new BrowserRuntimeError('NOT_RUNNING');
+        return this.listenPort;
+    }
+    get project() {
+        return this.projectId;
+    }
+    get allowedTargetPorts() {
+        return [...this.allowedPorts];
+    }
+    getStats() {
+        return {
+            ordinaryRequests: this.ordinaryRequests,
+            upgradeRequests: this.upgradeRequests,
+            connectRequests: this.connectRequests,
+            rejectedRequests: this.rejectedRequests,
+            activeConnections: this.clientSockets.size,
+        };
+    }
+    start() {
+        if (this.lifecycleState === 'running')
+            return Promise.resolve();
+        if (this.startPromise)
+            return this.startPromise;
+        if (this.stopPromise)
+            return this.stopPromise.then(() => this.start());
+        this.stopPromise = undefined;
+        this.lifecycleState = 'starting';
+        this.lifecycleController = new AbortController();
+        this.startPromise = this.startInternal().then(() => {
+            if (this.lifecycleState !== 'starting')
+                throw new BrowserRuntimeError('ABORTED');
+            this.lifecycleState = 'running';
+        }).catch((error) => {
+            if (this.lifecycleState === 'starting')
+                this.lifecycleState = 'stopped';
+            throw error;
+        }).finally(() => {
+            this.startPromise = undefined;
+        });
+        return this.startPromise;
+    }
+    stop() {
+        if (this.stopPromise)
+            return this.stopPromise;
+        if (this.lifecycleState === 'stopped' && !this.server && !this.startPromise) {
+            return Promise.resolve();
+        }
+        this.lifecycleState = 'stopping';
+        this.lifecycleController.abort(new BrowserRuntimeError('ABORTED'));
+        const startup = this.startPromise;
+        this.stopPromise = (async () => {
+            await startup?.catch(() => undefined);
+            await this.stopInternal();
+            this.lifecycleState = 'stopped';
+        })().finally(() => {
+            this.stopPromise = undefined;
+        });
+        return this.stopPromise;
+    }
+    async startInternal() {
+        const server = plugins.http.createServer({ maxHeaderSize: this.maxHeaderBytes }, (request, response) => {
+            if (!this.admit()) {
+                this.rejectedRequests += 1;
+                this.sendSafeFailure(response, 503);
+                return;
+            }
+            this.track(this.handleHttpRequest(request, response));
+        });
+        this.server = server;
+        server.on('connection', (socket) => {
+            if (this.clientSockets.size >= this.maxConnections) {
+                socket.destroy();
+                return;
+            }
+            this.clientSockets.add(socket);
+            socket.on('error', () => socket.destroy());
+            socket.setTimeout(this.idleTimeoutMs, () => socket.destroy());
+            socket.once('close', () => this.clientSockets.delete(socket));
+        });
+        server.on('connect', (request, socket, head) => {
+            if (!this.admit()) {
+                this.rejectedRequests += 1;
+                this.rejectRawSocket(socket, 502, false);
+                return;
+            }
+            this.track(this.handleConnect(request, socket, head));
+        });
+        server.on('upgrade', (request, socket, head) => {
+            if (!this.admit()) {
+                this.rejectedRequests += 1;
+                this.rejectRawSocket(socket, 502, false);
+                return;
+            }
+            this.track(this.handleUpgrade(request, socket, head));
+        });
+        server.on('clientError', (_error, socket) => {
+            this.rejectedRequests += 1;
+            if (socket.writable) {
+                socket.end('HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n');
+            }
+            else {
+                socket.destroy();
+            }
+        });
+        server.on('error', () => {
+            if (this.lifecycleState === 'running')
+                void this.stop().catch(() => undefined);
+        });
+        server.headersTimeout = this.requestTimeoutMs;
+        server.requestTimeout = this.requestTimeoutMs;
+        server.maxRequestsPerSocket = this.maxActiveRequests;
+        await new Promise((resolve, reject) => {
+            const onError = (error) => {
+                server.off('listening', onListening);
+                reject(error);
+            };
+            const onListening = () => {
+                server.off('error', onError);
+                resolve();
+            };
+            server.once('error', onError);
+            server.once('listening', onListening);
+            server.listen(0, '127.0.0.1');
+        });
+        const address = server.address();
+        if (!address || typeof address === 'string' || address.address !== '127.0.0.1') {
+            await this.stopInternal();
+            throw new BrowserRuntimeError('FENCED', 'proxy did not bind to IPv4 loopback');
+        }
+        this.listenPort = address.port;
+    }
+    async stopInternal() {
+        const server = this.server;
+        this.listenPort = undefined;
+        for (const socket of this.clientSockets)
+            socket.destroy();
+        for (const socket of this.upstreamSockets)
+            socket.destroy();
+        if (server) {
+            await new Promise((resolve, reject) => {
+                server.close((error) => {
+                    if (error && error.code !== 'ERR_SERVER_NOT_RUNNING') {
+                        reject(error);
+                    }
+                    else {
+                        resolve();
+                    }
+                });
+            });
+        }
+        const settled = await waitBounded(Promise.allSettled([...this.activeOperations]).then(() => undefined), this.requestTimeoutMs);
+        if (!settled.settled)
+            throw new BrowserRuntimeError('TIMEOUT');
+        this.server = undefined;
+        this.startPromise = undefined;
+    }
+    track(operation) {
+        const observed = operation.catch(() => undefined).finally(() => {
+            this.activeOperations.delete(observed);
+        });
+        this.activeOperations.add(observed);
+    }
+    admit() {
+        return this.lifecycleState !== 'stopping'
+            && this.activeOperations.size < this.maxActiveRequests;
+    }
+    async handleHttpRequest(request, response) {
+        this.ordinaryRequests += 1;
+        if (!this.authorize(request)) {
+            this.sendProxyAuthenticationRequired(response);
+            return;
+        }
+        request.pause();
+        let upstreamRequest;
+        let upstreamSocket;
+        let upstreamResponse;
+        let agent;
+        const operation = this.createOperationSignal();
+        const abort = () => operation.controller.abort(new BrowserRuntimeError('ABORTED'));
+        request.once('aborted', abort);
+        request.socket.once('close', abort);
+        response.once('close', () => {
+            if (!response.writableFinished)
+                abort();
+        });
+        try {
+            const contentLength = Number(request.headers['content-length']);
+            if (Number.isFinite(contentLength)
+                && contentLength > this.maxRequestBytes)
+                throw new BrowserRuntimeError('QUOTA_EXCEEDED');
+            const target = await this.resolveAbsoluteTarget(request.url, false, operation.signal);
+            operation.signal.throwIfAborted();
+            upstreamSocket = this.openUpstream(target, operation.signal);
+            await this.waitForConnect(upstreamSocket, operation.signal);
+            const headers = this.sanitizeHeaders(request.headers);
+            headers.host = target.hostHeader;
+            agent = new plugins.http.Agent({ keepAlive: false });
+            agent.createConnection = () => upstreamSocket;
+            upstreamRequest = plugins.http.request({
+                method: request.method,
+                host: target.address,
+                family: target.family,
+                port: target.port,
+                path: target.path,
+                headers,
+                agent,
+                maxHeaderSize: this.maxHeaderBytes,
+            });
+            const onAbort = () => {
+                upstreamRequest?.destroy(operation.signal.reason);
+                upstreamResponse?.destroy(operation.signal.reason);
+                upstreamSocket?.destroy(operation.signal.reason);
+            };
+            operation.signal.addEventListener('abort', onAbort, { once: true });
+            let requestBytes = 0;
+            request.on('data', (chunk) => {
+                requestBytes += chunk.byteLength;
+                if (requestBytes > this.maxRequestBytes) {
+                    operation.controller.abort(new BrowserRuntimeError('QUOTA_EXCEEDED'));
+                }
+            });
+            const upstreamResponsePromise = new Promise((resolve, reject) => {
+                upstreamRequest.once('response', resolve);
+                upstreamRequest.once('error', reject);
+            });
+            request.pipe(upstreamRequest);
+            upstreamResponse = await this.raceAbort(upstreamResponsePromise, operation.signal);
+            const responseLength = Number(upstreamResponse.headers['content-length']);
+            if (Number.isFinite(responseLength) && responseLength > this.maxResponseBytes) {
+                throw new BrowserRuntimeError('QUOTA_EXCEEDED');
+            }
+            const responseHeaders = this.sanitizeHeaders(upstreamResponse.headers);
+            response.writeHead(upstreamResponse.statusCode ?? 502, responseHeaders);
+            let responseBytes = 0;
+            upstreamResponse.on('data', (chunk) => {
+                responseBytes += chunk.byteLength;
+                if (responseBytes > this.maxResponseBytes) {
+                    operation.controller.abort(new BrowserRuntimeError('QUOTA_EXCEEDED'));
+                }
+            });
+            upstreamResponse.once('aborted', abort);
+            const responseFailure = new Promise((_resolve, reject) => {
+                upstreamResponse.once('error', reject);
+            });
+            upstreamResponse.pipe(response);
+            await Promise.race([this.waitForResponseCompletion(response), responseFailure]);
+            operation.signal.throwIfAborted();
+        }
+        catch {
+            this.rejectedRequests += 1;
+            upstreamRequest?.destroy();
+            upstreamSocket?.destroy();
+            if (!response.headersSent)
+                this.sendSafeFailure(response, 502);
+            else
+                response.destroy();
+        }
+        finally {
+            operation.dispose();
+            request.off('aborted', abort);
+            request.socket.off('close', abort);
+            upstreamResponse?.destroy();
+            upstreamRequest?.destroy();
+            upstreamSocket?.destroy();
+            agent?.destroy();
+        }
+    }
+    async handleConnect(request, clientSocket, head) {
+        this.connectRequests += 1;
+        if (!this.authorize(request)) {
+            this.rejectRawSocket(clientSocket, 407, true);
+            return;
+        }
+        clientSocket.pause();
+        const operation = this.createOperationSignal();
+        const abort = () => operation.controller.abort(new BrowserRuntimeError('ABORTED'));
+        clientSocket.once('close', abort);
+        let upstream;
+        try {
+            if (head.byteLength > this.maxTunnelBytes)
+                throw new BrowserRuntimeError('QUOTA_EXCEEDED');
+            const target = await this.resolveAuthority(request.url, operation.signal);
+            upstream = this.openUpstream(target, operation.signal);
+            await this.waitForConnect(upstream, operation.signal);
+            operation.signal.throwIfAborted();
+            clientSocket.write('HTTP/1.1 200 Connection Established\r\n\r\n');
+            await this.pipeTunnel(clientSocket, upstream, {
+                toUpstream: head,
+                toClient: plugins.Buffer.alloc(0),
+            }, operation.signal);
+        }
+        catch {
+            this.rejectedRequests += 1;
+            upstream?.destroy();
+            this.rejectRawSocket(clientSocket, 502, false);
+        }
+        finally {
+            operation.dispose();
+            clientSocket.off('close', abort);
+        }
+    }
+    async handleUpgrade(request, clientSocket, head) {
+        this.upgradeRequests += 1;
+        if (!this.authorize(request)) {
+            this.rejectRawSocket(clientSocket, 407, true);
+            return;
+        }
+        clientSocket.pause();
+        const operation = this.createOperationSignal();
+        const abort = () => operation.controller.abort(new BrowserRuntimeError('ABORTED'));
+        clientSocket.once('close', abort);
+        let upstream;
+        try {
+            if (request.method !== 'GET'
+                || String(request.headers.upgrade).toLowerCase() !== 'websocket'
+                || !String(request.headers.connection).toLowerCase().split(',')
+                    .map((value) => value.trim()).includes('upgrade'))
+                throw new BrowserRuntimeError('EGRESS_DENIED');
+            const webSocketKey = validateBoundedString(request.headers['sec-websocket-key'], 'sec-websocket-key', 20, 32);
+            if (request.headers['sec-websocket-version'] !== '13'
+                || !/^[A-Za-z0-9+/]{22}==$/.test(webSocketKey)
+                || plugins.Buffer.from(webSocketKey, 'base64').toString('base64') !== webSocketKey)
+                throw new BrowserRuntimeError('EGRESS_DENIED');
+            const expectedAccept = plugins.crypto
+                .createHash('sha1')
+                .update(`${webSocketKey}258EAFA5-E914-47DA-95CA-C5AB0DC85B11`, 'ascii')
+                .digest('base64');
+            if (head.byteLength > this.maxTunnelBytes)
+                throw new BrowserRuntimeError('QUOTA_EXCEEDED');
+            const target = await this.resolveAbsoluteTarget(request.url, true, operation.signal);
+            upstream = this.openUpstream(target, operation.signal);
+            await this.waitForConnect(upstream, operation.signal);
+            const headers = this.sanitizeHeaders(request.headers);
+            headers.host = target.hostHeader;
+            headers.connection = 'Upgrade';
+            headers.upgrade = 'websocket';
+            const headerLines = Object.entries(headers).flatMap(([name, value]) => (Array.isArray(value)
+                ? value.map((entry) => `${name}: ${entry}`)
+                : value === undefined
+                    ? []
+                    : [`${name}: ${value}`]));
+            upstream.write(`${request.method ?? 'GET'} ${target.path} HTTP/1.1\r\n${headerLines.join('\r\n')}\r\n\r\n`);
+            const handshake = await this.readWebSocketHandshake(upstream, operation.signal, expectedAccept);
+            clientSocket.write(handshake.header);
+            await this.pipeTunnel(clientSocket, upstream, { toUpstream: head, toClient: handshake.remaining }, operation.signal);
+        }
+        catch {
+            this.rejectedRequests += 1;
+            upstream?.destroy();
+            this.rejectRawSocket(clientSocket, 502, false);
+        }
+        finally {
+            operation.dispose();
+            clientSocket.off('close', abort);
+        }
+    }
+    authorize(request) {
+        const value = request.headers['proxy-authorization'];
+        if (typeof value !== 'string') {
+            this.rejectedRequests += 1;
+            return false;
+        }
+        const supplied = plugins.Buffer.from(value, 'utf8');
+        const accepted = supplied.byteLength === this.expectedAuthorization.byteLength
+            && plugins.crypto.timingSafeEqual(supplied, this.expectedAuthorization);
+        if (!accepted)
+            this.rejectedRequests += 1;
+        return accepted;
+    }
+    sendProxyAuthenticationRequired(response) {
+        response.writeHead(407, {
+            connection: 'close',
+            'content-length': '0',
+            'proxy-authenticate': 'Basic realm="browser-runtime"',
+        });
+        response.end();
+    }
+    sendSafeFailure(response, status) {
+        response.writeHead(status, { connection: 'close', 'content-length': '0' });
+        response.end();
+    }
+    rejectRawSocket(socket, status, authenticate) {
+        if (!socket.writable) {
+            socket.destroy();
+            return;
+        }
+        const statusText = status === 407 ? 'Proxy Authentication Required' : 'Bad Gateway';
+        const challenge = authenticate
+            ? 'Proxy-Authenticate: Basic realm="browser-runtime"\r\n'
+            : '';
+        socket.end(`HTTP/1.1 ${status} ${statusText}\r\n${challenge}Connection: close\r\nContent-Length: 0\r\n\r\n`);
+    }
+    sanitizeHeaders(headers) {
+        const connectionTokens = new Set((typeof headers.connection === 'string' ? headers.connection : '')
+            .split(',')
+            .map((token) => token.trim().toLowerCase())
+            .filter(Boolean));
+        const result = {};
+        for (const [name, value] of Object.entries(headers)) {
+            const normalizedName = name.toLowerCase();
+            if (hopByHopHeaders.has(normalizedName) || connectionTokens.has(normalizedName))
+                continue;
+            result[normalizedName] = value;
+        }
+        return result;
+    }
+    async resolveAbsoluteTarget(rawUrl, upgrade, signal) {
+        if (!rawUrl || plugins.Buffer.byteLength(rawUrl, 'utf8') > 8192) {
+            throw new BrowserRuntimeError('EGRESS_DENIED');
+        }
+        let parsed;
+        try {
+            parsed = new URL(rawUrl);
+        }
+        catch {
+            throw new BrowserRuntimeError('EGRESS_DENIED');
+        }
+        const allowedProtocols = upgrade ? new Set(['http:', 'ws:']) : new Set(['http:']);
+        if (!allowedProtocols.has(parsed.protocol)
+            || parsed.username
+            || parsed.password
+            || parsed.hash) {
+            throw new BrowserRuntimeError('EGRESS_DENIED');
+        }
+        const hostname = this.canonicalizeHostname(parsed.hostname);
+        const port = parsed.port
+            ? validateInteger(Number(parsed.port), 'target port', 1, 65535)
+            : 80;
+        const resolved = await this.resolveHost(hostname, port, signal);
+        return {
+            ...resolved,
+            path: `${parsed.pathname || '/'}${parsed.search}`,
+            hostHeader: parsed.host,
+        };
+    }
+    async resolveAuthority(rawAuthority, signal) {
+        if (!rawAuthority
+            || rawAuthority.length > 512
+            || /[\/?#@]/.test(rawAuthority)) {
+            throw new BrowserRuntimeError('EGRESS_DENIED');
+        }
+        let hostnameValue;
+        let portValue;
+        if (rawAuthority.startsWith('[')) {
+            const closingBracket = rawAuthority.indexOf(']');
+            if (closingBracket < 2 || rawAuthority[closingBracket + 1] !== ':') {
+                throw new BrowserRuntimeError('EGRESS_DENIED');
+            }
+            hostnameValue = rawAuthority.slice(1, closingBracket);
+            portValue = rawAuthority.slice(closingBracket + 2);
+        }
+        else {
+            const separator = rawAuthority.lastIndexOf(':');
+            if (separator < 1 || rawAuthority.indexOf(':') !== separator) {
+                throw new BrowserRuntimeError('EGRESS_DENIED');
+            }
+            hostnameValue = rawAuthority.slice(0, separator);
+            portValue = rawAuthority.slice(separator + 1);
+        }
+        if (!/^\d{1,5}$/.test(portValue))
+            throw new BrowserRuntimeError('EGRESS_DENIED');
+        const hostname = this.canonicalizeHostname(hostnameValue);
+        const port = validateInteger(Number(portValue), 'target port', 1, 65535);
+        const resolved = await this.resolveHost(hostname, port, signal);
+        return { ...resolved, path: '', hostHeader: rawAuthority };
+    }
+    canonicalizeHostname(hostnameArg) {
+        const unbracketed = hostnameArg.startsWith('[') && hostnameArg.endsWith(']')
+            ? hostnameArg.slice(1, -1)
+            : hostnameArg;
+        if (!unbracketed || unbracketed.length > 253 || unbracketed.includes('%')) {
+            throw new BrowserRuntimeError('EGRESS_DENIED');
+        }
+        if (plugins.ipaddr.isValid(unbracketed)) {
+            return plugins.ipaddr.parse(unbracketed).toNormalizedString();
+        }
+        const withoutTrailingDot = unbracketed.endsWith('.') ? unbracketed.slice(0, -1) : unbracketed;
+        const ascii = plugins.url.domainToASCII(withoutTrailingDot).toLowerCase();
+        if (!ascii
+            || ascii.length > 253
+            || !ascii.includes('.')
+            || ascii.split('.').some((label) => (label.length < 1
+                || label.length > 63
+                || !/^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/.test(label)))) {
+            throw new BrowserRuntimeError('EGRESS_DENIED');
+        }
+        return ascii;
+    }
+    async resolveHost(hostname, port, signal) {
+        if (!this.allowedPorts.has(port)) {
+            throw new BrowserRuntimeError('EGRESS_DENIED');
+        }
+        const answers = plugins.ipaddr.isValid(hostname)
+            ? [{ address: hostname, family: plugins.ipaddr.parse(hostname).kind() === 'ipv4' ? 4 : 6 }]
+            : await this.raceAbort(this.resolver(hostname, { all: true, verbatim: true, signal }), signal);
+        signal.throwIfAborted();
+        if (!Array.isArray(answers) || answers.length < 1 || answers.length > 64) {
+            throw new BrowserRuntimeError('EGRESS_DENIED');
+        }
+        const validated = answers.map((answer) => {
+            if (!answer
+                || (answer.family !== 4 && answer.family !== 6)
+                || typeof answer.address !== 'string'
+                || answer.address.includes('%')
+                || !plugins.ipaddr.isValid(answer.address)) {
+                throw new BrowserRuntimeError('EGRESS_DENIED');
+            }
+            const parsed = plugins.ipaddr.parse(answer.address);
+            if ((parsed.kind() === 'ipv6'
+                && parsed.isIPv4MappedAddress())
+                || parsed.range() !== 'unicast'
+                || (parsed.kind() === 'ipv6'
+                    && !parsed.match(plugins.ipaddr.parse('2000::'), 3))) {
+                throw new BrowserRuntimeError('EGRESS_DENIED');
+            }
+            const family = parsed.kind() === 'ipv4' ? 4 : 6;
+            if (family !== answer.family)
+                throw new BrowserRuntimeError('EGRESS_DENIED');
+            return { address: parsed.toNormalizedString(), family };
+        });
+        return { ...validated[0], hostname, port };
+    }
+    openUpstream(target, signal) {
+        const options = {
+            address: target.address,
+            family: target.family,
+            port: target.port,
+            hostname: target.hostname,
+            signal,
+        };
+        const socket = this.connector(options);
+        if (!(socket instanceof plugins.net.Socket)) {
+            throw new BrowserRuntimeError('EGRESS_DENIED');
+        }
+        this.upstreamSockets.add(socket);
+        socket.on('error', () => socket.destroy());
+        socket.setTimeout(this.idleTimeoutMs, () => socket.destroy());
+        socket.once('close', () => this.upstreamSockets.delete(socket));
+        if (signal.aborted)
+            socket.destroy(signal.reason);
+        else
+            signal.addEventListener('abort', () => socket.destroy(signal.reason), { once: true });
+        return socket;
+    }
+    async waitForConnect(socket, signal) {
+        if (!socket.connecting
+            && !socket.pending
+            && !socket.destroyed
+            && socket.remoteAddress)
+            return;
+        if (!socket.connecting || socket.destroyed)
+            throw new BrowserRuntimeError('EGRESS_DENIED');
+        await new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                cleanup();
+                socket.destroy();
+                reject(new BrowserRuntimeError('TIMEOUT'));
+            }, this.connectTimeoutMs);
+            timer.unref();
+            const cleanup = () => {
+                clearTimeout(timer);
+                socket.off('connect', onConnect);
+                socket.off('error', onError);
+                socket.off('close', onClose);
+                signal.removeEventListener('abort', onAbort);
+            };
+            const onConnect = () => {
+                cleanup();
+                resolve();
+            };
+            const onError = () => {
+                cleanup();
+                reject(new BrowserRuntimeError('EGRESS_DENIED'));
+            };
+            const onClose = () => {
+                cleanup();
+                reject(new BrowserRuntimeError('EGRESS_DENIED'));
+            };
+            const onAbort = () => {
+                cleanup();
+                socket.destroy(signal.reason);
+                reject(signal.reason);
+            };
+            socket.once('connect', onConnect);
+            socket.once('error', onError);
+            socket.once('close', onClose);
+            signal.addEventListener('abort', onAbort, { once: true });
+        });
+    }
+    async pipeTunnel(clientSocket, upstream, initial, signal) {
+        let transferred = initial.toUpstream.byteLength + initial.toClient.byteLength;
+        if (transferred > this.maxTunnelBytes)
+            throw new BrowserRuntimeError('QUOTA_EXCEEDED');
+        const lifetimeTimer = setTimeout(() => {
+            clientSocket.destroy();
+            upstream.destroy();
+        }, this.tunnelLifetimeMs);
+        lifetimeTimer.unref();
+        const count = (chunk) => {
+            transferred += chunk.byteLength;
+            if (transferred > this.maxTunnelBytes) {
+                clientSocket.destroy();
+                upstream.destroy();
+            }
+        };
+        clientSocket.on('data', count);
+        upstream.on('data', count);
+        const onAbort = () => {
+            clientSocket.destroy(signal.reason);
+            upstream.destroy(signal.reason);
+        };
+        signal.addEventListener('abort', onAbort, { once: true });
+        if (initial.toUpstream.byteLength > 0)
+            upstream.write(initial.toUpstream);
+        if (initial.toClient.byteLength > 0)
+            clientSocket.write(initial.toClient);
+        clientSocket.pipe(upstream);
+        upstream.pipe(clientSocket);
+        clientSocket.resume();
+        await Promise.race([
+            new Promise((resolve) => clientSocket.once('close', resolve)),
+            new Promise((resolve) => upstream.once('close', resolve)),
+        ]);
+        clearTimeout(lifetimeTimer);
+        clientSocket.off('data', count);
+        upstream.off('data', count);
+        signal.removeEventListener('abort', onAbort);
+        clientSocket.destroy();
+        upstream.destroy();
+    }
+    async readWebSocketHandshake(upstream, signal, expectedAccept) {
+        const data = await new Promise((resolve, reject) => {
+            let buffered = plugins.Buffer.alloc(0);
+            const cleanup = () => {
+                upstream.off('data', onData);
+                upstream.off('error', onError);
+                upstream.off('close', onClose);
+                signal.removeEventListener('abort', onAbort);
+            };
+            const onData = (chunk) => {
+                buffered = plugins.Buffer.concat([buffered, chunk]);
+                const boundary = buffered.indexOf('\r\n\r\n');
+                if (boundary < 0 && buffered.byteLength > this.maxHeaderBytes) {
+                    cleanup();
+                    reject(new BrowserRuntimeError('QUOTA_EXCEEDED'));
+                    return;
+                }
+                if (boundary < 0)
+                    return;
+                if (boundary + 4 > this.maxHeaderBytes) {
+                    cleanup();
+                    reject(new BrowserRuntimeError('QUOTA_EXCEEDED'));
+                    return;
+                }
+                cleanup();
+                resolve(buffered);
+            };
+            const onError = () => {
+                cleanup();
+                reject(new BrowserRuntimeError('EGRESS_DENIED'));
+            };
+            const onClose = () => {
+                cleanup();
+                reject(new BrowserRuntimeError('EGRESS_DENIED'));
+            };
+            const onAbort = () => {
+                cleanup();
+                reject(signal.reason);
+            };
+            upstream.on('data', onData);
+            upstream.once('error', onError);
+            upstream.once('close', onClose);
+            signal.addEventListener('abort', onAbort, { once: true });
+        });
+        const boundary = data.indexOf('\r\n\r\n');
+        const header = data.subarray(0, boundary + 4);
+        const statusLine = header.subarray(0, header.indexOf('\r\n')).toString('latin1');
+        if (!/^HTTP\/1\.[01] 101(?: |$)/.test(statusLine)) {
+            throw new BrowserRuntimeError('EGRESS_DENIED');
+        }
+        const headerLines = header.toString('latin1').split('\r\n').slice(1, -2);
+        const headers = new Map();
+        for (const headerLine of headerLines) {
+            const separator = headerLine.indexOf(':');
+            if (separator < 1)
+                throw new BrowserRuntimeError('EGRESS_DENIED');
+            const name = headerLine.slice(0, separator).trim().toLowerCase();
+            const value = headerLine.slice(separator + 1).trim();
+            const values = headers.get(name) ?? [];
+            values.push(value);
+            headers.set(name, values);
+        }
+        const connectionTokens = (headers.get('connection') ?? [])
+            .flatMap((value) => value.split(','))
+            .map((value) => value.trim().toLowerCase());
+        if (!connectionTokens.includes('upgrade')
+            || headers.get('upgrade')?.length !== 1
+            || headers.get('upgrade')?.[0]?.toLowerCase() !== 'websocket'
+            || headers.get('sec-websocket-accept')?.length !== 1
+            || headers.get('sec-websocket-accept')?.[0] !== expectedAccept)
+            throw new BrowserRuntimeError('EGRESS_DENIED');
+        return { header, remaining: data.subarray(boundary + 4) };
+    }
+    createOperationSignal() {
+        const controller = new AbortController();
+        const timeoutController = new AbortController();
+        const timeout = setTimeout(() => {
+            timeoutController.abort(new BrowserRuntimeError('TIMEOUT'));
+        }, this.requestTimeoutMs);
+        timeout.unref();
+        return {
+            controller,
+            signal: AbortSignal.any([
+                controller.signal,
+                timeoutController.signal,
+                this.lifecycleController.signal,
+            ]),
+            dispose: () => clearTimeout(timeout),
+        };
+    }
+    async raceAbort(promise, signal) {
+        signal.throwIfAborted();
+        let onAbort;
+        const aborted = new Promise((_resolve, reject) => {
+            onAbort = () => reject(signal.reason);
+            signal.addEventListener('abort', onAbort, { once: true });
+        });
+        try {
+            return await Promise.race([promise, aborted]);
+        }
+        finally {
+            signal.removeEventListener('abort', onAbort);
+        }
+    }
+    async waitForResponseCompletion(response) {
+        if (response.writableFinished || response.destroyed)
+            return;
+        await new Promise((resolve) => {
+            const settle = () => {
+                response.off('finish', settle);
+                response.off('close', settle);
+                resolve();
+            };
+            response.once('finish', settle);
+            response.once('close', settle);
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.egressproxy.js","sourceRoot":"","sources":["../ts/classes.egressproxy.ts"],"names":[],"mappings":"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"}