@push.rocks/smartproxy 25.12.0 → 25.13.0

package/changelog.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 2026-03-19 - 25.13.0 - feat(smart-proxy)
+add UDP transport support with QUIC/HTTP3 routing and datagram handler relay
+
+- adds UDP listener and session tracking infrastructure in the Rust proxy, including UDP metrics and hot-reload support for transport-specific ports
+- introduces QUIC and HTTP/3 support in routing and HTTP handling, including Alt-Svc advertisement and QUIC TLS configuration
+- extends route configuration types in Rust and TypeScript with transport, UDP, QUIC, backend transport, and mixed port range support
+- adds a TypeScript datagram handler relay server and bridge command so UDP socket-handler routes can dispatch datagrams to application callbacks
+- updates nftables rule generation so protocol=all creates both TCP and UDP rules
+
 ## 2026-03-19 - 25.12.0 - feat(proxy-protocol)
 add PROXY protocol v2 support to the Rust passthrough listener and streamline TypeScript proxy protocol exports
 

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@push.rocks/smartproxy',
-    version: '25.12.0',
+    version: '25.13.0',
     description: 'A powerful proxy package with unified route-based configuration for high traffic management. Features include SSL/TLS support, flexible routing patterns, WebSocket handling, advanced security options, and automatic ACME certificate management.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSx3QkFBd0I7SUFDOUIsT0FBTyxFQUFFLFNBQVM7SUFDbEIsV0FBVyxFQUFFLHFQQUFxUDtDQUNuUSxDQUFBIn0=

package/dist_ts/proxies/smart-proxy/datagram-handler-server.d.ts

@@ -0,0 +1,46 @@
+import type { RoutePreprocessor } from './route-preprocessor.js';
+/**
+ * Server that receives UDP datagrams from Rust via Unix stream socket
+ * and dispatches them to TypeScript datagramHandler callbacks.
+ *
+ * Protocol: length-prefixed JSON frames over a persistent Unix stream socket.
+ * - Rust→TS: { type: "datagram", routeKey, sourceIp, sourcePort, destPort, payloadBase64 }
+ * - TS→Rust: { type: "reply", sourceIp, sourcePort, destPort, payloadBase64 }
+ */
+export declare class DatagramHandlerServer {
+    private server;
+    private connection;
+    private socketPath;
+    private preprocessor;
+    private readBuffer;
+    constructor(socketPath: string, preprocessor: RoutePreprocessor);
+    /**
+     * Start listening on the Unix socket.
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the server and clean up.
+     */
+    stop(): Promise<void>;
+    /**
+     * Handle a new connection from Rust.
+     * Only one connection at a time (Rust maintains a persistent connection).
+     */
+    private handleConnection;
+    /**
+     * Process length-prefixed frames from the read buffer.
+     */
+    private processFrames;
+    /**
+     * Handle a received datagram message from Rust.
+     */
+    private handleMessage;
+    /**
+     * Send a reply frame back to Rust.
+     */
+    private sendReply;
+    /**
+     * Get the socket path for passing to Rust via IPC.
+     */
+    getSocketPath(): string;
+}

package/dist_ts/proxies/smart-proxy/datagram-handler-server.js

@@ -0,0 +1,197 @@
+import * as plugins from '../../plugins.js';
+import { logger } from '../../core/utils/logger.js';
+/**
+ * Server that receives UDP datagrams from Rust via Unix stream socket
+ * and dispatches them to TypeScript datagramHandler callbacks.
+ *
+ * Protocol: length-prefixed JSON frames over a persistent Unix stream socket.
+ * - Rust→TS: { type: "datagram", routeKey, sourceIp, sourcePort, destPort, payloadBase64 }
+ * - TS→Rust: { type: "reply", sourceIp, sourcePort, destPort, payloadBase64 }
+ */
+export class DatagramHandlerServer {
+    constructor(socketPath, preprocessor) {
+        this.server = null;
+        this.connection = null;
+        this.readBuffer = Buffer.alloc(0);
+        this.socketPath = socketPath;
+        this.preprocessor = preprocessor;
+    }
+    /**
+     * Start listening on the Unix socket.
+     */
+    async start() {
+        // Clean up stale socket file
+        try {
+            await plugins.fs.promises.unlink(this.socketPath);
+        }
+        catch {
+            // Ignore if doesn't exist
+        }
+        return new Promise((resolve, reject) => {
+            this.server = plugins.net.createServer((socket) => {
+                this.handleConnection(socket);
+            });
+            this.server.on('error', (err) => {
+                logger.log('error', `DatagramHandlerServer error: ${err.message}`);
+                reject(err);
+            });
+            this.server.listen(this.socketPath, () => {
+                logger.log('info', `DatagramHandlerServer listening on ${this.socketPath}`);
+                resolve();
+            });
+        });
+    }
+    /**
+     * Stop the server and clean up.
+     */
+    async stop() {
+        if (this.connection) {
+            this.connection.destroy();
+            this.connection = null;
+        }
+        if (this.server) {
+            await new Promise((resolve) => {
+                this.server.close(() => resolve());
+            });
+            this.server = null;
+        }
+        try {
+            await plugins.fs.promises.unlink(this.socketPath);
+        }
+        catch {
+            // Ignore
+        }
+    }
+    /**
+     * Handle a new connection from Rust.
+     * Only one connection at a time (Rust maintains a persistent connection).
+     */
+    handleConnection(socket) {
+        if (this.connection) {
+            logger.log('warn', 'DatagramHandlerServer: replacing existing connection');
+            this.connection.destroy();
+        }
+        this.connection = socket;
+        this.readBuffer = Buffer.alloc(0);
+        socket.on('data', (chunk) => {
+            this.readBuffer = Buffer.concat([this.readBuffer, chunk]);
+            this.processFrames();
+        });
+        socket.on('error', (err) => {
+            logger.log('error', `DatagramHandlerServer connection error: ${err.message}`);
+        });
+        socket.on('close', () => {
+            if (this.connection === socket) {
+                this.connection = null;
+            }
+        });
+        logger.log('info', 'DatagramHandlerServer: Rust relay connected');
+    }
+    /**
+     * Process length-prefixed frames from the read buffer.
+     */
+    processFrames() {
+        while (this.readBuffer.length >= 4) {
+            const frameLen = this.readBuffer.readUInt32BE(0);
+            // Safety: reject absurdly large frames
+            if (frameLen > 10 * 1024 * 1024) {
+                logger.log('error', `DatagramHandlerServer: frame too large (${frameLen} bytes), resetting`);
+                this.readBuffer = Buffer.alloc(0);
+                return;
+            }
+            if (this.readBuffer.length < 4 + frameLen) {
+                // Incomplete frame, wait for more data
+                return;
+            }
+            const frameData = this.readBuffer.subarray(4, 4 + frameLen);
+            this.readBuffer = this.readBuffer.subarray(4 + frameLen);
+            try {
+                const msg = JSON.parse(frameData.toString('utf8'));
+                this.handleMessage(msg);
+            }
+            catch (err) {
+                logger.log('error', `DatagramHandlerServer: failed to parse frame: ${err}`);
+            }
+        }
+    }
+    /**
+     * Handle a received datagram message from Rust.
+     */
+    handleMessage(msg) {
+        if (msg.type !== 'datagram') {
+            return;
+        }
+        const originalRoute = this.preprocessor.getOriginalRoute(msg.routeKey);
+        if (!originalRoute) {
+            logger.log('warn', `DatagramHandlerServer: no handler for route '${msg.routeKey}'`);
+            return;
+        }
+        const handler = originalRoute.action.datagramHandler;
+        if (!handler) {
+            logger.log('warn', `DatagramHandlerServer: route '${msg.routeKey}' has no datagramHandler`);
+            return;
+        }
+        const datagram = Buffer.from(msg.payloadBase64, 'base64');
+        const context = {
+            port: msg.destPort,
+            domain: undefined,
+            clientIp: msg.sourceIp,
+            serverIp: '0.0.0.0',
+            path: undefined,
+            isTls: false,
+            tlsVersion: undefined,
+            routeName: originalRoute.name,
+            routeId: originalRoute.id,
+            timestamp: Date.now(),
+            connectionId: `udp-${msg.sourceIp}:${msg.sourcePort}-${Date.now()}`,
+        };
+        const info = {
+            sourceIp: msg.sourceIp,
+            sourcePort: msg.sourcePort,
+            destPort: msg.destPort,
+            context,
+        };
+        const reply = (data) => {
+            this.sendReply({
+                type: 'reply',
+                routeKey: msg.routeKey,
+                sourceIp: msg.sourceIp,
+                sourcePort: msg.sourcePort,
+                destPort: msg.destPort,
+                payloadBase64: data.toString('base64'),
+            });
+        };
+        try {
+            const result = handler(datagram, info, reply);
+            if (result && typeof result.catch === 'function') {
+                result.catch((err) => {
+                    logger.log('error', `DatagramHandler error for route '${msg.routeKey}': ${err}`);
+                });
+            }
+        }
+        catch (err) {
+            logger.log('error', `DatagramHandler threw for route '${msg.routeKey}': ${err}`);
+        }
+    }
+    /**
+     * Send a reply frame back to Rust.
+     */
+    sendReply(msg) {
+        if (!this.connection || this.connection.destroyed) {
+            logger.log('warn', 'DatagramHandlerServer: cannot send reply, no connection');
+            return;
+        }
+        const json = JSON.stringify(msg);
+        const payload = Buffer.from(json, 'utf8');
+        const header = Buffer.alloc(4);
+        header.writeUInt32BE(payload.length, 0);
+        this.connection.write(Buffer.concat([header, payload]));
+    }
+    /**
+     * Get the socket path for passing to Rust via IPC.
+     */
+    getSocketPath() {
+        return this.socketPath;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/proxies/smart-proxy/models/metrics-types.d.ts

@@ -67,6 +67,12 @@ export interface IMetrics {
             errors: number;
         }>;
     };
+    udp: {
+        activeSessions(): number;
+        totalSessions(): number;
+        datagramsIn(): number;
+        datagramsOut(): number;
+    };
     percentiles: {
         connectionDuration(): {
             p50: number;

package/dist_ts/proxies/smart-proxy/models/route-types.d.ts

@@ -14,9 +14,14 @@ export type TSocketHandler = (socket: plugins.net.Socket, context: IRouteContext
  */
 export type TTlsMode = 'passthrough' | 'terminate' | 'terminate-and-reencrypt';
 /**
- * Port range specification format
+ * Transport protocol for route matching
  */
-export type TPortRange = number | number[] | Array<{
+export type TTransportProtocol = 'tcp' | 'udp' | 'all';
+/**
+ * Port range specification format.
+ * Supports: single number, array of numbers, array of ranges, or mixed arrays.
+ */
+export type TPortRange = number | Array<number | {
     from: number;
     to: number;
 }>;
@@ -25,12 +30,13 @@ export type TPortRange = number | number[] | Array<{
  */
 export interface IRouteMatch {
     ports: TPortRange;
+    transport?: TTransportProtocol;
     domains?: string | string[];
     path?: string;
     clientIp?: string[];
     tlsVersion?: string[];
     headers?: Record<string, string | RegExp>;
-    protocol?: 'http' | 'tcp';
+    protocol?: 'http' | 'tcp' | 'udp' | 'quic' | 'http3';
 }
 /**
  * Target-specific match criteria for sub-routing within a route
@@ -54,6 +60,7 @@ export interface IRouteTarget {
     sendProxyProtocol?: boolean;
     headers?: IRouteHeaders;
     advanced?: IRouteAdvanced;
+    backendTransport?: 'tcp' | 'udp';
     priority?: number;
 }
 /**
@@ -209,13 +216,15 @@ export interface IRouteAction {
     loadBalancing?: IRouteLoadBalancing;
     advanced?: IRouteAdvanced;
     options?: {
-        backendProtocol?: 'http1' | 'http2' | 'auto';
+        backendProtocol?: 'http1' | 'http2' | 'http3' | 'auto';
         [key: string]: any;
     };
     forwardingEngine?: 'node' | 'nftables';
     nftables?: INfTablesOptions;
     socketHandler?: TSocketHandler;
+    datagramHandler?: TDatagramHandler;
     sendProxyProtocol?: boolean;
+    udp?: IRouteUdp;
 }
 /**
  * Rate limiting configuration
@@ -276,3 +285,53 @@ export interface IRouteConfig {
     tags?: string[];
     enabled?: boolean;
 }
+/**
+ * Handler for individual UDP datagrams.
+ * Called for each incoming datagram on a socket-handler route with UDP transport.
+ */
+export type TDatagramHandler = (datagram: Buffer, info: IDatagramInfo, reply: (data: Buffer) => void) => void | Promise<void>;
+/**
+ * Metadata for a received UDP datagram
+ */
+export interface IDatagramInfo {
+    /** Source IP address */
+    sourceIp: string;
+    /** Source port */
+    sourcePort: number;
+    /** Destination (local) port the datagram arrived on */
+    destPort: number;
+    /** Route context */
+    context: IRouteContext;
+}
+/**
+ * UDP-specific settings for route actions
+ */
+export interface IRouteUdp {
+    /** Idle timeout for a UDP session/flow (keyed by src IP:port), in ms. Default: 60000 */
+    sessionTimeout?: number;
+    /** Max concurrent UDP sessions per source IP. Default: 1000 */
+    maxSessionsPerIP?: number;
+    /** Max accepted datagram size in bytes. Oversized datagrams are dropped. Default: 65535 */
+    maxDatagramSize?: number;
+    /** QUIC-specific configuration. When present, traffic is treated as QUIC. */
+    quic?: IRouteQuic;
+}
+/**
+ * QUIC and HTTP/3 settings
+ */
+export interface IRouteQuic {
+    /** QUIC connection idle timeout in ms. Default: 30000 */
+    maxIdleTimeout?: number;
+    /** Max concurrent bidirectional streams per QUIC connection. Default: 100 */
+    maxConcurrentBidiStreams?: number;
+    /** Max concurrent unidirectional streams per QUIC connection. Default: 100 */
+    maxConcurrentUniStreams?: number;
+    /** Enable HTTP/3 over this QUIC endpoint. Default: false */
+    enableHttp3?: boolean;
+    /** Port to advertise in Alt-Svc header on TCP HTTP responses. Default: listening port */
+    altSvcPort?: number;
+    /** Max age for Alt-Svc advertisement in seconds. Default: 86400 */
+    altSvcMaxAge?: number;
+    /** Initial congestion window size in bytes. Default: implementation-defined */
+    initialCongestionWindow?: number;
+}

package/dist_ts/proxies/smart-proxy/models/route-types.js

@@ -1,3 +1,3 @@
 import * as plugins from '../../../plugins.js';
 // Configuration moved to models/interfaces.ts as ISmartProxyOptions
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm91dGUtdHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi90cy9wcm94aWVzL3NtYXJ0LXByb3h5L21vZGVscy9yb3V0ZS10eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssT0FBTyxNQUFNLHFCQUFxQixDQUFDO0FBc1cvQyxvRUFBb0UifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm91dGUtdHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi90cy9wcm94aWVzL3NtYXJ0LXByb3h5L21vZGVscy9yb3V0ZS10eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssT0FBTyxNQUFNLHFCQUFxQixDQUFDO0FBb2IvQyxvRUFBb0UifQ==

package/dist_ts/proxies/smart-proxy/route-preprocessor.js

@@ -63,6 +63,10 @@ export class RoutePreprocessor {
         if (route.action.type === 'socket-handler' && route.action.socketHandler) {
             return true;
         }
+        // Datagram handler routes always need TS
+        if (route.action.type === 'socket-handler' && route.action.datagramHandler) {
+            return true;
+        }
         // Routes with dynamic host/port functions need TS
         if (route.action.targets) {
             for (const target of route.action.targets) {
@@ -78,8 +82,9 @@ export class RoutePreprocessor {
         if (needsTsHandling) {
             // Convert to socket-handler type for Rust (Rust will relay back to TS)
             cleanAction.type = 'socket-handler';
-            // Remove the JS handler (not serializable)
+            // Remove the JS handlers (not serializable)
             delete cleanAction.socketHandler;
+            delete cleanAction.datagramHandler;
         }
         // Clean targets - replace functions with static values
         if (cleanAction.targets) {
@@ -100,4 +105,4 @@ export class RoutePreprocessor {
         return clean;
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/proxies/smart-proxy/rust-metrics-adapter.d.ts

@@ -60,6 +60,12 @@ export declare class RustMetricsAdapter implements IMetrics {
             errors: number;
         }>;
     };
+    udp: {
+        activeSessions: () => number;
+        totalSessions: () => number;
+        datagramsIn: () => number;
+        datagramsOut: () => number;
+    };
     percentiles: {
         connectionDuration: () => {
             p50: number;

package/dist_ts/proxies/smart-proxy/rust-metrics-adapter.js

@@ -174,6 +174,12 @@ export class RustMetricsAdapter {
                 return result.slice(0, limit);
             },
         };
+        this.udp = {
+            activeSessions: () => this.cache?.activeUdpSessions ?? 0,
+            totalSessions: () => this.cache?.totalUdpSessions ?? 0,
+            datagramsIn: () => this.cache?.totalDatagramsIn ?? 0,
+            datagramsOut: () => this.cache?.totalDatagramsOut ?? 0,
+        };
         this.percentiles = {
             connectionDuration: () => {
                 return { p50: 0, p95: 0, p99: 0 };
@@ -218,4 +224,4 @@ export class RustMetricsAdapter {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rust-metrics-adapter.js","sourceRoot":"","sources":["../../../ts/proxies/smart-proxy/rust-metrics-adapter.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;GAUG;AACH,MAAM,OAAO,kBAAkB;IAM7B,YAAY,MAAuB,EAAE,cAAc,GAAG,IAAI;QAJlD,UAAK,GAAQ,IAAI,CAAC;QAClB,cAAS,GAA0C,IAAI,CAAC;QAsChE,kCAAkC;QAE3B,gBAAW,GAAG;YACnB,MAAM,EAAE,GAAW,EAAE;gBACnB,OAAO,IAAI,CAAC,KAAK,EAAE,iBAAiB,IAAI,CAAC,CAAC;YAC5C,CAAC;YACD,KAAK,EAAE,GAAW,EAAE;gBAClB,OAAO,IAAI,CAAC,KAAK,EAAE,gBAAgB,IAAI,CAAC,CAAC;YAC3C,CAAC;YACD,OAAO,EAAE,GAAwB,EAAE;gBACjC,MAAM,MAAM,GAAG,IAAI,GAAG,EAAkB,CAAC;gBACzC,IAAI,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,CAAC;oBACvB,KAAK,MAAM,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC;wBAC3D,MAAM,CAAC,GAAG,CAAC,IAAI,EAAG,EAAU,CAAC,iBAAiB,IAAI,CAAC,CAAC,CAAC;oBACvD,CAAC;gBACH,CAAC;gBACD,OAAO,MAAM,CAAC;YAChB,CAAC;YACD,IAAI,EAAE,GAAwB,EAAE;gBAC9B,MAAM,MAAM,GAAG,IAAI,GAAG,EAAkB,CAAC;gBACzC,IAAI,IAAI,CAAC,KAAK,EAAE,GAAG,EAAE,CAAC;oBACpB,KAAK,MAAM,CAAC,EAAE,EAAE,EAAE,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC;wBACtD,MAAM,CAAC,GAAG,CAAC,EAAE,EAAG,EAAU,CAAC,iBAAiB,IAAI,CAAC,CAAC,CAAC;oBACrD,CAAC;gBACH,CAAC;gBACD,OAAO,MAAM,CAAC;YAChB,CAAC;YACD,MAAM,EAAE,CAAC,QAAgB,EAAE,EAAwC,EAAE;gBACnE,MAAM,MAAM,GAAyC,EAAE,CAAC;gBACxD,IAAI,IAAI,CAAC,KAAK,EAAE,GAAG,EAAE,CAAC;oBACpB,KAAK,MAAM,CAAC,EAAE,EAAE,EAAE,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC;wBACtD,MAAM,CAAC,IAAI,CAAC,EAAE,EAAE,EAAE,KAAK,EAAG,EAAU,CAAC,iBAAiB,IAAI,CAAC,EAAE,CAAC,CAAC;oBACjE,CAAC;gBACH,CAAC;gBACD,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC;gBACzC,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;YAChC,CAAC;SACF,CAAC;QAEK,eAAU,GAAG;YAClB,OAAO,EAAE,GAAoB,EAAE;gBAC7B,OAAO;oBACL,EAAE,EAAE,IAAI,CAAC,KAAK,EAAE,uBAAuB,IAAI,CAAC;oBAC5C,GAAG,EAAE,IAAI,CAAC,KAAK,EAAE,wBAAwB,IAAI,CAAC;iBAC/C,CAAC;YACJ,CAAC;YACD,MAAM,EAAE,GAAoB,EAAE;gBAC5B,OAAO;oBACL,EAAE,EAAE,IAAI,CAAC,KAAK,EAAE,6BAA6B,IAAI,CAAC;oBAClD,GAAG,EAAE,IAAI,CAAC,KAAK,EAAE,8BAA8B,IAAI,CAAC;iBACrD,CAAC;YACJ,CAAC;YACD,OAAO,EAAE,GAAoB,EAAE;gBAC7B,OAAO,IAAI,CAAC,UAAU,CAAC,OAAO,EAAE,CAAC;YACnC,CAAC;YACD,MAAM,EAAE,CAAC,QAAgB,EAAmB,EAAE;gBAC5C,OAAO,IAAI,CAAC,UAAU,CAAC,OAAO,EAAE,CAAC;YACnC,CAAC;YACD,OAAO,EAAE,CAAC,OAAe,EAAkC,EAAE;gBAC3D,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,iBAAiB;oBAAE,OAAO,EAAE,CAAC;gBAC9C,OAAO,IAAI,CAAC,KAAK,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC;oBACnE,SAAS,EAAE,CAAC,CAAC,WAAW;oBACxB,EAAE,EAAE,CAAC,CAAC,OAAO;oBACb,GAAG,EAAE,CAAC,CAAC,QAAQ;iBAChB,CAAC,CAAC,CAAC;YACN,CAAC;YACD,OAAO,EAAE,CAAC,cAAuB,EAAgC,EAAE;gBACjE,MAAM,MAAM,GAAG,IAAI,GAAG,EAA2B,CAAC;gBAClD,IAAI,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,CAAC;oBACvB,KAAK,MAAM,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC;wBAC3D,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE;4BACf,EAAE,EAAG,EAAU,CAAC,uBAAuB,IAAI,CAAC;4BAC5C,GAAG,EAAG,EAAU,CAAC,wBAAwB,IAAI,CAAC;yBAC/C,CAAC,CAAC;oBACL,CAAC;gBACH,CAAC;gBACD,OAAO,MAAM,CAAC;YAChB,CAAC;YACD,IAAI,EAAE,CAAC,cAAuB,EAAgC,EAAE;gBAC9D,MAAM,MAAM,GAAG,IAAI,GAAG,EAA2B,CAAC;gBAClD,IAAI,IAAI,CAAC,KAAK,EAAE,GAAG,EAAE,CAAC;oBACpB,KAAK,MAAM,CAAC,EAAE,EAAE,EAAE,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC;wBACtD,MAAM,CAAC,GAAG,CAAC,EAAE,EAAE;4BACb,EAAE,EAAG,EAAU,CAAC,uBAAuB,IAAI,CAAC;4BAC5C,GAAG,EAAG,EAAU,CAAC,wBAAwB,IAAI,CAAC;yBAC/C,CAAC,CAAC;oBACL,CAAC;gBACH,CAAC;gBACD,OAAO,MAAM,CAAC;YAChB,CAAC;SACF,CAAC;QAEK,aAAQ,GAAG;YAChB,SAAS,EAAE,GAAW,EAAE;gBACtB,OAAO,IAAI,CAAC,KAAK,EAAE,kBAAkB,IAAI,CAAC,CAAC;YAC7C,CAAC;YACD,SAAS,EAAE,GAAW,EAAE;gBACtB,OAAO,CAAC,IAAI,CAAC,KAAK,EAAE,wBAAwB,IAAI,CAAC,CAAC,GAAG,EAAE,CAAC;YAC1D,CAAC;YACD,KAAK,EAAE,GAAW,EAAE;gBAClB,OAAO,IAAI,CAAC,KAAK,EAAE,iBAAiB,IAAI,IAAI,CAAC,KAAK,EAAE,gBAAgB,IAAI,CAAC,CAAC;YAC5E,CAAC;SACF,CAAC;QAEK,WAAM,GAAG;YACd,OAAO,EAAE,GAAW,EAAE;gBACpB,OAAO,IAAI,CAAC,KAAK,EAAE,OAAO,IAAI,CAAC,CAAC;YAClC,CAAC;YACD,QAAQ,EAAE,GAAW,EAAE;gBACrB,OAAO,IAAI,CAAC,KAAK,EAAE,QAAQ,IAAI,CAAC,CAAC;YACnC,CAAC;YACD,WAAW,EAAE,GAAW,EAAE;gBACxB,OAAO,IAAI,CAAC,KAAK,EAAE,gBAAgB,IAAI,CAAC,CAAC;YAC3C,CAAC;SACF,CAAC;QAEK,aAAQ,GAAG;YAChB,SAAS,EAAE,GAAiC,EAAE;gBAC5C,MAAM,MAAM,GAAG,IAAI,GAAG,EAA2B,CAAC;gBAClD,IAAI,IAAI,CAAC,KAAK,EAAE,QAAQ,EAAE,CAAC;oBACzB,KAAK,MAAM,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,CAAC;wBAC5D,MAAM,CAAC,GAAG,EAAS,CAAC;wBACpB,MAAM,WAAW,GAAG,CAAC,CAAC,kBAAkB,IAAI,CAAC,CAAC;wBAC9C,MAAM,KAAK,GAAG,CAAC,CAAC,YAAY,IAAI,CAAC,CAAC;wBAClC,MAAM,QAAQ,GAAG,CAAC,CAAC,QAAQ,IAAI,CAAC,CAAC;wBACjC,MAAM,UAAU,GAAG,CAAC,CAAC,UAAU,IAAI,CAAC,CAAC;wBACrC,MAAM,SAAS,GAAG,QAAQ,GAAG,UAAU,CAAC;wBACxC,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE;4BACd,QAAQ,EAAE,CAAC,CAAC,QAAQ,IAAI,SAAS;4BACjC,iBAAiB,EAAE,CAAC,CAAC,iBAAiB,IAAI,CAAC;4BAC3C,gBAAgB,EAAE,CAAC,CAAC,gBAAgB,IAAI,CAAC;4BACzC,aAAa,EAAE,CAAC,CAAC,aAAa,IAAI,CAAC;4BACnC,eAAe,EAAE,CAAC,CAAC,eAAe,IAAI,CAAC;4BACvC,aAAa,EAAE,CAAC,CAAC,aAAa,IAAI,CAAC;4BACnC,gBAAgB,EAAE,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,WAAW,GAAG,KAAK,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;4BAC9D,WAAW,EAAE,SAAS,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC;4BACrD,UAAU,EAAE,CAAC,CAAC,UAAU,IAAI,CAAC;yBAC9B,CAAC,CAAC;oBACL,CAAC;gBACH,CAAC;gBACD,OAAO,MAAM,CAAC;YAChB,CAAC;YACD,SAAS,EAAE,GAAwB,EAAE;gBACnC,MAAM,MAAM,GAAG,IAAI,GAAG,EAAkB,CAAC;gBACzC,IAAI,IAAI,CAAC,KAAK,EAAE,QAAQ,EAAE,CAAC;oBACzB,KAAK,MAAM,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,CAAC;wBAC5D,MAAM,CAAC,GAAG,CAAC,GAAG,EAAG,EAAU,CAAC,QAAQ,IAAI,SAAS,CAAC,CAAC;oBACrD,CAAC;gBACH,CAAC;gBACD,OAAO,MAAM,CAAC;YAChB,CAAC;YACD,WAAW,EAAE,CAAC,QAAgB,EAAE,EAA8C,EAAE;gBAC9E,MAAM,MAAM,GAA+C,EAAE,CAAC;gBAC9D,IAAI,IAAI,CAAC,KAAK,EAAE,QAAQ,EAAE,CAAC;oBACzB,KAAK,MAAM,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,CAAC;wBAC5D,MAAM,CAAC,GAAG,EAAS,CAAC;wBACpB,MAAM,MAAM,GAAG,CAAC,CAAC,CAAC,aAAa,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,eAAe,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,aAAa,IAAI,CAAC,CAAC,CAAC;wBAC1F,IAAI,MAAM,GAAG,CAAC;4BAAE,MAAM,CAAC,IAAI,CAAC,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,CAAC,CAAC;oBACxD,CAAC;gBACH,CAAC;gBACD,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC;gBAC3C,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;YAChC,CAAC;SACF,CAAC;QAEK,gBAAW,GAAG;YACnB,kBAAkB,EAAE,GAA8C,EAAE;gBAClE,OAAO,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC;YACpC,CAAC;YACD,gBAAgB,EAAE,GAGhB,EAAE;gBACF,OAAO;oBACL,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE;oBAC9B,GAAG,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE;iBAChC,CAAC;YACJ,CAAC;SACF,CAAC;QApNA,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,cAAc,GAAG,cAAc,CAAC;IACvC,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,IAAI;QACf,IAAI,CAAC;YACH,IAAI,CAAC,KAAK,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC;QAC9C,CAAC;QAAC,MAAM,CAAC;YACP,mDAAmD;QACrD,CAAC;IACH,CAAC;IAEM,YAAY;QACjB,IAAI,IAAI,CAAC,SAAS;YAAE,OAAO;QAC3B,kDAAkD;QAClD,IAAI,CAAC,IAAI,EAAE,CAAC;QACZ,IAAI,CAAC,SAAS,GAAG,WAAW,CAAC,GAAG,EAAE;YAChC,IAAI,CAAC,IAAI,EAAE,CAAC;QACd,CAAC,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC;QACxB,IAAI,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,CAAC;YACzB,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,CAAC;QACzB,CAAC;IACH,CAAC;IAEM,WAAW;QAChB,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YACnB,aAAa,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;YAC9B,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;QACxB,CAAC;IACH,CAAC;CAqLF"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rust-metrics-adapter.js","sourceRoot":"","sources":["../../../ts/proxies/smart-proxy/rust-metrics-adapter.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;GAUG;AACH,MAAM,OAAO,kBAAkB;IAM7B,YAAY,MAAuB,EAAE,cAAc,GAAG,IAAI;QAJlD,UAAK,GAAQ,IAAI,CAAC;QAClB,cAAS,GAA0C,IAAI,CAAC;QAsChE,kCAAkC;QAE3B,gBAAW,GAAG;YACnB,MAAM,EAAE,GAAW,EAAE;gBACnB,OAAO,IAAI,CAAC,KAAK,EAAE,iBAAiB,IAAI,CAAC,CAAC;YAC5C,CAAC;YACD,KAAK,EAAE,GAAW,EAAE;gBAClB,OAAO,IAAI,CAAC,KAAK,EAAE,gBAAgB,IAAI,CAAC,CAAC;YAC3C,CAAC;YACD,OAAO,EAAE,GAAwB,EAAE;gBACjC,MAAM,MAAM,GAAG,IAAI,GAAG,EAAkB,CAAC;gBACzC,IAAI,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,CAAC;oBACvB,KAAK,MAAM,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC;wBAC3D,MAAM,CAAC,GAAG,CAAC,IAAI,EAAG,EAAU,CAAC,iBAAiB,IAAI,CAAC,CAAC,CAAC;oBACvD,CAAC;gBACH,CAAC;gBACD,OAAO,MAAM,CAAC;YAChB,CAAC;YACD,IAAI,EAAE,GAAwB,EAAE;gBAC9B,MAAM,MAAM,GAAG,IAAI,GAAG,EAAkB,CAAC;gBACzC,IAAI,IAAI,CAAC,KAAK,EAAE,GAAG,EAAE,CAAC;oBACpB,KAAK,MAAM,CAAC,EAAE,EAAE,EAAE,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC;wBACtD,MAAM,CAAC,GAAG,CAAC,EAAE,EAAG,EAAU,CAAC,iBAAiB,IAAI,CAAC,CAAC,CAAC;oBACrD,CAAC;gBACH,CAAC;gBACD,OAAO,MAAM,CAAC;YAChB,CAAC;YACD,MAAM,EAAE,CAAC,QAAgB,EAAE,EAAwC,EAAE;gBACnE,MAAM,MAAM,GAAyC,EAAE,CAAC;gBACxD,IAAI,IAAI,CAAC,KAAK,EAAE,GAAG,EAAE,CAAC;oBACpB,KAAK,MAAM,CAAC,EAAE,EAAE,EAAE,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC;wBACtD,MAAM,CAAC,IAAI,CAAC,EAAE,EAAE,EAAE,KAAK,EAAG,EAAU,CAAC,iBAAiB,IAAI,CAAC,EAAE,CAAC,CAAC;oBACjE,CAAC;gBACH,CAAC;gBACD,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC;gBACzC,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;YAChC,CAAC;SACF,CAAC;QAEK,eAAU,GAAG;YAClB,OAAO,EAAE,GAAoB,EAAE;gBAC7B,OAAO;oBACL,EAAE,EAAE,IAAI,CAAC,KAAK,EAAE,uBAAuB,IAAI,CAAC;oBAC5C,GAAG,EAAE,IAAI,CAAC,KAAK,EAAE,wBAAwB,IAAI,CAAC;iBAC/C,CAAC;YACJ,CAAC;YACD,MAAM,EAAE,GAAoB,EAAE;gBAC5B,OAAO;oBACL,EAAE,EAAE,IAAI,CAAC,KAAK,EAAE,6BAA6B,IAAI,CAAC;oBAClD,GAAG,EAAE,IAAI,CAAC,KAAK,EAAE,8BAA8B,IAAI,CAAC;iBACrD,CAAC;YACJ,CAAC;YACD,OAAO,EAAE,GAAoB,EAAE;gBAC7B,OAAO,IAAI,CAAC,UAAU,CAAC,OAAO,EAAE,CAAC;YACnC,CAAC;YACD,MAAM,EAAE,CAAC,QAAgB,EAAmB,EAAE;gBAC5C,OAAO,IAAI,CAAC,UAAU,CAAC,OAAO,EAAE,CAAC;YACnC,CAAC;YACD,OAAO,EAAE,CAAC,OAAe,EAAkC,EAAE;gBAC3D,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,iBAAiB;oBAAE,OAAO,EAAE,CAAC;gBAC9C,OAAO,IAAI,CAAC,KAAK,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC;oBACnE,SAAS,EAAE,CAAC,CAAC,WAAW;oBACxB,EAAE,EAAE,CAAC,CAAC,OAAO;oBACb,GAAG,EAAE,CAAC,CAAC,QAAQ;iBAChB,CAAC,CAAC,CAAC;YACN,CAAC;YACD,OAAO,EAAE,CAAC,cAAuB,EAAgC,EAAE;gBACjE,MAAM,MAAM,GAAG,IAAI,GAAG,EAA2B,CAAC;gBAClD,IAAI,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,CAAC;oBACvB,KAAK,MAAM,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC;wBAC3D,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE;4BACf,EAAE,EAAG,EAAU,CAAC,uBAAuB,IAAI,CAAC;4BAC5C,GAAG,EAAG,EAAU,CAAC,wBAAwB,IAAI,CAAC;yBAC/C,CAAC,CAAC;oBACL,CAAC;gBACH,CAAC;gBACD,OAAO,MAAM,CAAC;YAChB,CAAC;YACD,IAAI,EAAE,CAAC,cAAuB,EAAgC,EAAE;gBAC9D,MAAM,MAAM,GAAG,IAAI,GAAG,EAA2B,CAAC;gBAClD,IAAI,IAAI,CAAC,KAAK,EAAE,GAAG,EAAE,CAAC;oBACpB,KAAK,MAAM,CAAC,EAAE,EAAE,EAAE,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC;wBACtD,MAAM,CAAC,GAAG,CAAC,EAAE,EAAE;4BACb,EAAE,EAAG,EAAU,CAAC,uBAAuB,IAAI,CAAC;4BAC5C,GAAG,EAAG,EAAU,CAAC,wBAAwB,IAAI,CAAC;yBAC/C,CAAC,CAAC;oBACL,CAAC;gBACH,CAAC;gBACD,OAAO,MAAM,CAAC;YAChB,CAAC;SACF,CAAC;QAEK,aAAQ,GAAG;YAChB,SAAS,EAAE,GAAW,EAAE;gBACtB,OAAO,IAAI,CAAC,KAAK,EAAE,kBAAkB,IAAI,CAAC,CAAC;YAC7C,CAAC;YACD,SAAS,EAAE,GAAW,EAAE;gBACtB,OAAO,CAAC,IAAI,CAAC,KAAK,EAAE,wBAAwB,IAAI,CAAC,CAAC,GAAG,EAAE,CAAC;YAC1D,CAAC;YACD,KAAK,EAAE,GAAW,EAAE;gBAClB,OAAO,IAAI,CAAC,KAAK,EAAE,iBAAiB,IAAI,IAAI,CAAC,KAAK,EAAE,gBAAgB,IAAI,CAAC,CAAC;YAC5E,CAAC;SACF,CAAC;QAEK,WAAM,GAAG;YACd,OAAO,EAAE,GAAW,EAAE;gBACpB,OAAO,IAAI,CAAC,KAAK,EAAE,OAAO,IAAI,CAAC,CAAC;YAClC,CAAC;YACD,QAAQ,EAAE,GAAW,EAAE;gBACrB,OAAO,IAAI,CAAC,KAAK,EAAE,QAAQ,IAAI,CAAC,CAAC;YACnC,CAAC;YACD,WAAW,EAAE,GAAW,EAAE;gBACxB,OAAO,IAAI,CAAC,KAAK,EAAE,gBAAgB,IAAI,CAAC,CAAC;YAC3C,CAAC;SACF,CAAC;QAEK,aAAQ,GAAG;YAChB,SAAS,EAAE,GAAiC,EAAE;gBAC5C,MAAM,MAAM,GAAG,IAAI,GAAG,EAA2B,CAAC;gBAClD,IAAI,IAAI,CAAC,KAAK,EAAE,QAAQ,EAAE,CAAC;oBACzB,KAAK,MAAM,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,CAAC;wBAC5D,MAAM,CAAC,GAAG,EAAS,CAAC;wBACpB,MAAM,WAAW,GAAG,CAAC,CAAC,kBAAkB,IAAI,CAAC,CAAC;wBAC9C,MAAM,KAAK,GAAG,CAAC,CAAC,YAAY,IAAI,CAAC,CAAC;wBAClC,MAAM,QAAQ,GAAG,CAAC,CAAC,QAAQ,IAAI,CAAC,CAAC;wBACjC,MAAM,UAAU,GAAG,CAAC,CAAC,UAAU,IAAI,CAAC,CAAC;wBACrC,MAAM,SAAS,GAAG,QAAQ,GAAG,UAAU,CAAC;wBACxC,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE;4BACd,QAAQ,EAAE,CAAC,CAAC,QAAQ,IAAI,SAAS;4BACjC,iBAAiB,EAAE,CAAC,CAAC,iBAAiB,IAAI,CAAC;4BAC3C,gBAAgB,EAAE,CAAC,CAAC,gBAAgB,IAAI,CAAC;4BACzC,aAAa,EAAE,CAAC,CAAC,aAAa,IAAI,CAAC;4BACnC,eAAe,EAAE,CAAC,CAAC,eAAe,IAAI,CAAC;4BACvC,aAAa,EAAE,CAAC,CAAC,aAAa,IAAI,CAAC;4BACnC,gBAAgB,EAAE,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,WAAW,GAAG,KAAK,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;4BAC9D,WAAW,EAAE,SAAS,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC;4BACrD,UAAU,EAAE,CAAC,CAAC,UAAU,IAAI,CAAC;yBAC9B,CAAC,CAAC;oBACL,CAAC;gBACH,CAAC;gBACD,OAAO,MAAM,CAAC;YAChB,CAAC;YACD,SAAS,EAAE,GAAwB,EAAE;gBACnC,MAAM,MAAM,GAAG,IAAI,GAAG,EAAkB,CAAC;gBACzC,IAAI,IAAI,CAAC,KAAK,EAAE,QAAQ,EAAE,CAAC;oBACzB,KAAK,MAAM,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,CAAC;wBAC5D,MAAM,CAAC,GAAG,CAAC,GAAG,EAAG,EAAU,CAAC,QAAQ,IAAI,SAAS,CAAC,CAAC;oBACrD,CAAC;gBACH,CAAC;gBACD,OAAO,MAAM,CAAC;YAChB,CAAC;YACD,WAAW,EAAE,CAAC,QAAgB,EAAE,EAA8C,EAAE;gBAC9E,MAAM,MAAM,GAA+C,EAAE,CAAC;gBAC9D,IAAI,IAAI,CAAC,KAAK,EAAE,QAAQ,EAAE,CAAC;oBACzB,KAAK,MAAM,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,CAAC;wBAC5D,MAAM,CAAC,GAAG,EAAS,CAAC;wBACpB,MAAM,MAAM,GAAG,CAAC,CAAC,CAAC,aAAa,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,eAAe,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,aAAa,IAAI,CAAC,CAAC,CAAC;wBAC1F,IAAI,MAAM,GAAG,CAAC;4BAAE,MAAM,CAAC,IAAI,CAAC,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,CAAC,CAAC;oBACxD,CAAC;gBACH,CAAC;gBACD,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC;gBAC3C,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;YAChC,CAAC;SACF,CAAC;QAEK,QAAG,GAAG;YACX,cAAc,EAAE,GAAW,EAAE,CAAC,IAAI,CAAC,KAAK,EAAE,iBAAiB,IAAI,CAAC;YAChE,aAAa,EAAE,GAAW,EAAE,CAAC,IAAI,CAAC,KAAK,EAAE,gBAAgB,IAAI,CAAC;YAC9D,WAAW,EAAE,GAAW,EAAE,CAAC,IAAI,CAAC,KAAK,EAAE,gBAAgB,IAAI,CAAC;YAC5D,YAAY,EAAE,GAAW,EAAE,CAAC,IAAI,CAAC,KAAK,EAAE,iBAAiB,IAAI,CAAC;SAC/D,CAAC;QAEK,gBAAW,GAAG;YACnB,kBAAkB,EAAE,GAA8C,EAAE;gBAClE,OAAO,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC;YACpC,CAAC;YACD,gBAAgB,EAAE,GAGhB,EAAE;gBACF,OAAO;oBACL,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE;oBAC9B,GAAG,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE;iBAChC,CAAC;YACJ,CAAC;SACF,CAAC;QA3NA,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,cAAc,GAAG,cAAc,CAAC;IACvC,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,IAAI;QACf,IAAI,CAAC;YACH,IAAI,CAAC,KAAK,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC;QAC9C,CAAC;QAAC,MAAM,CAAC;YACP,mDAAmD;QACrD,CAAC;IACH,CAAC;IAEM,YAAY;QACjB,IAAI,IAAI,CAAC,SAAS;YAAE,OAAO;QAC3B,kDAAkD;QAClD,IAAI,CAAC,IAAI,EAAE,CAAC;QACZ,IAAI,CAAC,SAAS,GAAG,WAAW,CAAC,GAAG,EAAE;YAChC,IAAI,CAAC,IAAI,EAAE,CAAC;QACd,CAAC,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC;QACxB,IAAI,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,CAAC;YACzB,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,CAAC;QACzB,CAAC;IACH,CAAC;IAEM,WAAW;QAChB,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YACnB,aAAa,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;YAC9B,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;QACxB,CAAC;IACH,CAAC;CA4LF"}

package/dist_ts/proxies/smart-proxy/rust-proxy-bridge.d.ts

@@ -34,4 +34,5 @@ export declare class RustProxyBridge extends plugins.EventEmitter {
     addListeningPort(port: number): Promise<void>;
     removeListeningPort(port: number): Promise<void>;
     loadCertificate(domain: string, cert: string, key: string, ca?: string): Promise<void>;
+    setDatagramHandlerRelay(socketPath: string): Promise<void>;
 }

package/dist_ts/proxies/smart-proxy/rust-proxy-bridge.js

@@ -127,5 +127,8 @@ export class RustProxyBridge extends plugins.EventEmitter {
     async loadCertificate(domain, cert, key, ca) {
         await this.bridge.sendCommand('loadCertificate', { domain, cert, key, ca });
     }
+    async setDatagramHandlerRelay(socketPath) {
+        await this.bridge.sendCommand('setDatagramHandlerRelay', { socketPath });
+    }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnVzdC1wcm94eS1icmlkZ2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9wcm94aWVzL3NtYXJ0LXByb3h5L3J1c3QtcHJveHktYnJpZGdlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0sa0JBQWtCLENBQUM7QUFDNUMsT0FBTyxFQUFFLE1BQU0sRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBd0JwRDs7O0dBR0c7QUFDSCxTQUFTLGNBQWM7SUFDckIsTUFBTSxPQUFPLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxhQUFhLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDO0lBQ2pGLE9BQU8sT0FBTyxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsT0FBTyxFQUFFLElBQUksRUFBRSxJQUFJLEVBQUUsSUFBSSxDQUFDLENBQUM7QUFDekQsQ0FBQztBQUVEOzs7R0FHRztBQUNILFNBQVMsdUJBQXVCO0lBQzlCLE1BQU0sT0FBTyxHQUEyQixFQUFFLEdBQUcsRUFBRSxPQUFPLEVBQUUsS0FBSyxFQUFFLE9BQU8sRUFBRSxDQUFDO0lBQ3pFLE1BQU0sS0FBSyxHQUEyQixFQUFFLEtBQUssRUFBRSxPQUFPLEVBQUUsTUFBTSxFQUFFLE9BQU8sRUFBRSxDQUFDO0lBQzFFLE1BQU0sRUFBRSxHQUFHLEtBQUssQ0FBQyxPQUFPLENBQUMsUUFBUSxDQUFDLENBQUM7SUFDbkMsTUFBTSxJQUFJLEdBQUcsT0FBTyxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUNuQyxJQUFJLEVBQUUsSUFBSSxJQUFJLEVBQUUsQ0FBQztRQUNmLE9BQU8sR0FBRyxFQUFFLElBQUksSUFBSSxFQUFFLENBQUM7SUFDekIsQ0FBQztJQUNELE9BQU8sSUFBSSxDQUFDO0FBQ2QsQ0FBQztBQUVEOzs7R0FHRztBQUNILFNBQVMsZUFBZTtJQUN0QixNQUFNLFdBQVcsR0FBRyxjQUFjLEVBQUUsQ0FBQztJQUNyQyxNQUFNLE1BQU0sR0FBRyx1QkFBdUIsRUFBRSxDQUFDO0lBQ3pDLE1BQU0sS0FBSyxHQUFhLEVBQUUsQ0FBQztJQUUzQix1REFBdUQ7SUFDdkQsSUFBSSxNQUFNLEVBQUUsQ0FBQztRQUNYLEtBQUssQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsV0FBVyxFQUFFLFdBQVcsRUFBRSxhQUFhLE1BQU0sRUFBRSxDQUFDLENBQUMsQ0FBQztJQUNqRixDQUFDO0lBQ0QsS0FBSyxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxXQUFXLEVBQUUsV0FBVyxFQUFFLFdBQVcsQ0FBQyxDQUFDLENBQUM7SUFFckUsd0JBQXdCO0lBQ3hCLEtBQUssQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsT0FBTyxDQUFDLEdBQUcsRUFBRSxFQUFFLE1BQU0sRUFBRSxRQUFRLEVBQUUsU0FBUyxFQUFFLFdBQVcsQ0FBQyxDQUFDLENBQUM7SUFDMUYsS0FBSyxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxPQUFPLENBQUMsR0FBRyxFQUFFLEVBQUUsTUFBTSxFQUFFLFFBQVEsRUFBRSxPQUFPLEVBQUUsV0FBVyxDQUFDLENBQUMsQ0FBQztJQUV4RixPQUFPLEtBQUssQ0FBQztBQUNmLENBQUM7QUFFRDs7O0dBR0c7QUFDSCxNQUFNLE9BQU8sZUFBZ0IsU0FBUSxPQUFPLENBQUMsWUFBWTtJQUd2RDtRQUNFLEtBQUssRUFBRSxDQUFDO1FBRVIsSUFBSSxDQUFDLE1BQU0sR0FBRyxJQUFJLE9BQU8sQ0FBQyxTQUFTLENBQUMsVUFBVSxDQUFzQjtZQUNsRSxVQUFVLEVBQUUsV0FBVztZQUN2QixVQUFVLEVBQUUsd0JBQXdCO1lBQ3BDLHFCQUFxQixFQUFFLHdCQUF3QjtZQUMvQyxVQUFVLEVBQUUsZUFBZSxFQUFFO1lBQzdCLGNBQWMsRUFBRSxHQUFHLEdBQUcsSUFBSSxHQUFHLElBQUksRUFBRSx3REFBd0Q7WUFDM0YsTUFBTSxFQUFFO2dCQUNOLEdBQUcsRUFBRSxDQUFDLEtBQWEsRUFBRSxPQUFlLEVBQUUsSUFBMEIsRUFBRSxFQUFFO29CQUNsRSxNQUFNLENBQUMsR0FBRyxDQUFDLEtBQVksRUFBRSxPQUFPLEVBQUUsSUFBSSxDQUFDLENBQUM7Z0JBQzFDLENBQUM7YUFDRjtTQUNGLENBQUMsQ0FBQztRQUVILHVDQUF1QztRQUN2QyxJQUFJLENBQUMsTUFBTSxDQUFDLEVBQUUsQ0FBQyxNQUFNLEVBQUUsQ0FBQyxJQUFtQixFQUFFLE1BQXFCLEVBQUUsRUFBRTtZQUNwRSxJQUFJLENBQUMsSUFBSSxDQUFDLE1BQU0sRUFBRSxJQUFJLEVBQUUsTUFBTSxDQUFDLENBQUM7UUFDbEMsQ0FBQyxDQUFDLENBQUM7SUFDTCxDQUFDO0lBRUQ7OztPQUdHO0lBQ0ksS0FBSyxDQUFDLEtBQUs7UUFDaEIsT0FBTyxJQUFJLENBQUMsTUFBTSxDQUFDLEtBQUssRUFBRSxDQUFDO0lBQzdCLENBQUM7SUFFRDs7T0FFRztJQUNJLElBQUk7UUFDVCxJQUFJLENBQUMsTUFBTSxDQUFDLElBQUksRUFBRSxDQUFDO0lBQ3JCLENBQUM7SUFFRDs7T0FFRztJQUNILElBQVcsT0FBTztRQUNoQixPQUFPLElBQUksQ0FBQyxNQUFNLENBQUMsT0FBTyxDQUFDO0lBQzdCLENBQUM7SUFFRCwwREFBMEQ7SUFFbkQsS0FBSyxDQUFDLFVBQVUsQ0FBQyxNQUFXO1FBQ2pDLE1BQU0sSUFBSSxDQUFDLE1BQU0sQ0FBQyxXQUFXLENBQUMsT0FBTyxFQUFFLEVBQUUsTUFBTSxFQUFFLENBQUMsQ0FBQztJQUNyRCxDQUFDO0lBRU0sS0FBSyxDQUFDLFNBQVM7UUFDcEIsTUFBTSxJQUFJLENBQUMsTUFBTSxDQUFDLFdBQVcsQ0FBQyxNQUFNLEVBQUUsRUFBMkIsQ0FBQyxDQUFDO0lBQ3JFLENBQUM7SUFFTSxLQUFLLENBQUMsWUFBWSxDQUFDLE1BQXNCO1FBQzlDLE1BQU0sSUFBSSxDQUFDLE1BQU0sQ0FBQyxXQUFXLENBQUMsY0FBYyxFQUFFLEVBQUUsTUFBTSxFQUFFLENBQUMsQ0FBQztJQUM1RCxDQUFDO0lBRU0sS0FBSyxDQUFDLFVBQVU7UUFDckIsT0FBTyxJQUFJLENBQUMsTUFBTSxDQUFDLFdBQVcsQ0FBQyxZQUFZLEVBQUUsRUFBMkIsQ0FBQyxDQUFDO0lBQzVFLENBQUM7SUFFTSxLQUFLLENBQUMsYUFBYTtRQUN4QixPQUFPLElBQUksQ0FBQyxNQUFNLENBQUMsV0FBVyxDQUFDLGVBQWUsRUFBRSxFQUEyQixDQUFDLENBQUM7SUFDL0UsQ0FBQztJQUVNLEtBQUssQ0FBQyxvQkFBb0IsQ0FBQyxTQUFpQjtRQUNqRCxNQUFNLElBQUksQ0FBQyxNQUFNLENBQUMsV0FBVyxDQUFDLHNCQUFzQixFQUFFLEVBQUUsU0FBUyxFQUFFLENBQUMsQ0FBQztJQUN2RSxDQUFDO0lBRU0sS0FBSyxDQUFDLGdCQUFnQixDQUFDLFNBQWlCO1FBQzdDLE1BQU0sSUFBSSxDQUFDLE1BQU0sQ0FBQyxXQUFXLENBQUMsa0JBQWtCLEVBQUUsRUFBRSxTQUFTLEVBQUUsQ0FBQyxDQUFDO0lBQ25FLENBQUM7SUFFTSxLQUFLLENBQUMsb0JBQW9CLENBQUMsU0FBaUI7UUFDakQsT0FBTyxJQUFJLENBQUMsTUFBTSxDQUFDLFdBQVcsQ0FBQyxzQkFBc0IsRUFBRSxFQUFFLFNBQVMsRUFBRSxDQUFDLENBQUM7SUFDeEUsQ0FBQztJQUVNLEtBQUssQ0FBQyxpQkFBaUI7UUFDNUIsTUFBTSxNQUFNLEdBQUcsTUFBTSxJQUFJLENBQUMsTUFBTSxDQUFDLFdBQVcsQ0FBQyxtQkFBbUIsRUFBRSxFQUEyQixDQUFDLENBQUM7UUFDL0YsT0FBTyxNQUFNLEVBQUUsS0FBSyxJQUFJLEVBQUUsQ0FBQztJQUM3QixDQUFDO0lBRU0sS0FBSyxDQUFDLGlCQUFpQjtRQUM1QixPQUFPLElBQUksQ0FBQyxNQUFNLENBQUMsV0FBVyxDQUFDLG1CQUFtQixFQUFFLEVBQTJCLENBQUMsQ0FBQztJQUNuRixDQUFDO0lBRU0sS0FBSyxDQUFDLHFCQUFxQixDQUFDLFVBQWtCO1FBQ25ELE1BQU0sSUFBSSxDQUFDLE1BQU0sQ0FBQyxXQUFXLENBQUMsdUJBQXVCLEVBQUUsRUFBRSxVQUFVLEVBQUUsQ0FBQyxDQUFDO0lBQ3pFLENBQUM7SUFFTSxLQUFLLENBQUMsZ0JBQWdCLENBQUMsSUFBWTtRQUN4QyxNQUFNLElBQUksQ0FBQyxNQUFNLENBQUMsV0FBVyxDQUFDLGtCQUFrQixFQUFFLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQztJQUM5RCxDQUFDO0lBRU0sS0FBSyxDQUFDLG1CQUFtQixDQUFDLElBQVk7UUFDM0MsTUFBTSxJQUFJLENBQUMsTUFBTSxDQUFDLFdBQVcsQ0FBQyxxQkFBcUIsRUFBRSxFQUFFLElBQUksRUFBRSxDQUFDLENBQUM7SUFDakUsQ0FBQztJQUVNLEtBQUssQ0FBQyxlQUFlLENBQUMsTUFBYyxFQUFFLElBQVksRUFBRSxHQUFXLEVBQUUsRUFBVztRQUNqRixNQUFNLElBQUksQ0FBQyxNQUFNLENBQUMsV0FBVyxDQUFDLGlCQUFpQixFQUFFLEVBQUUsTUFBTSxFQUFFLElBQUksRUFBRSxHQUFHLEVBQUUsRUFBRSxFQUFFLENBQUMsQ0FBQztJQUM5RSxDQUFDO0lBRU0sS0FBSyxDQUFDLHVCQUF1QixDQUFDLFVBQWtCO1FBQ3JELE1BQU0sSUFBSSxDQUFDLE1BQU0sQ0FBQyxXQUFXLENBQUMseUJBQXlCLEVBQUUsRUFBRSxVQUFVLEVBQUUsQ0FBQyxDQUFDO0lBQzNFLENBQUM7Q0FDRiJ9

package/dist_ts/proxies/smart-proxy/smart-proxy.d.ts

@@ -19,6 +19,7 @@ export declare class SmartProxy extends plugins.EventEmitter {
     private bridge;
     private preprocessor;
     private socketHandlerServer;
+    private datagramHandlerServer;
     private metricsAdapter;
     private routeUpdateLock;
     private stopping;