@push.rocks/smartproxy 27.5.0 → 27.7.0

package/changelog.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## 2026-04-13 - 27.7.0 - feat(smart-proxy)
+add typed Rust config serialization and regex header contract coverage
+
+- serialize SmartProxy routes and top-level options into explicit Rust-safe types, including header regex literals, UDP field normalization, ACME, defaults, and proxy settings
+- support JS-style regex header literals with flags in Rust header matching and add cross-contract tests for route preprocessing and config deserialization
+- improve TypeScript safety for Rust bridge and metrics integration by replacing loose any-based payloads with dedicated Rust type definitions
+
+## 2026-04-13 - 27.6.0 - feat(metrics)
+track per-IP domain request metrics across HTTP and TCP passthrough traffic
+
+- records domain request counts per frontend IP from HTTP Host headers and TCP SNI
+- exposes per-IP domain maps and top IP-domain request pairs through the TypeScript metrics adapter
+- bounds per-IP domain tracking and prunes stale entries to limit memory growth
+- adds metrics system documentation covering architecture, collected data, and known gaps
+
 ## 2026-04-06 - 27.5.0 - feat(security)
 add domain-scoped IP allow list support across HTTP and passthrough filtering
 

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@push.rocks/smartproxy',
-    version: '27.5.0',
+    version: '27.7.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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSx3QkFBd0I7SUFDOUIsT0FBTyxFQUFFLFFBQVE7SUFDakIsV0FBVyxFQUFFLHFQQUFxUDtDQUNuUSxDQUFBIn0=

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

@@ -55,6 +55,14 @@ export interface IMetrics {
             ip: string;
             count: number;
         }>;
+        /** Per-IP domain request counts: IP -> { domain -> count }. */
+        domainRequestsByIP(): Map<string, Map<string, number>>;
+        /** Top IP-domain pairs sorted by request count descending. */
+        topDomainRequests(limit?: number): Array<{
+            ip: string;
+            domain: string;
+            count: number;
+        }>;
         frontendProtocols(): IProtocolDistribution;
         backendProtocols(): IProtocolDistribution;
     };

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

@@ -0,0 +1,136 @@
+import type { IProtocolCacheEntry, IProtocolDistribution } from './metrics-types.js';
+import type { IAcmeOptions, ISmartProxyOptions } from './interfaces.js';
+import type { IRouteAction, IRouteConfig, IRouteMatch, IRouteTarget, ITargetMatch, IRouteUdp } from './route-types.js';
+export type TRustHeaderMatchers = Record<string, string>;
+export interface IRustRouteMatch extends Omit<IRouteMatch, 'headers'> {
+    headers?: TRustHeaderMatchers;
+}
+export interface IRustTargetMatch extends Omit<ITargetMatch, 'headers'> {
+    headers?: TRustHeaderMatchers;
+}
+export interface IRustRouteTarget extends Omit<IRouteTarget, 'host' | 'port' | 'match'> {
+    host: string | string[];
+    port: number | 'preserve';
+    match?: IRustTargetMatch;
+}
+export interface IRustRouteUdp extends Omit<IRouteUdp, 'maxSessionsPerIP'> {
+    maxSessionsPerIp?: number;
+}
+export interface IRustDefaultConfig extends Omit<NonNullable<ISmartProxyOptions['defaults']>, 'preserveSourceIP'> {
+    preserveSourceIp?: boolean;
+}
+export interface IRustRouteAction extends Omit<IRouteAction, 'targets' | 'socketHandler' | 'datagramHandler' | 'forwardingEngine' | 'nftables' | 'udp'> {
+    targets?: IRustRouteTarget[];
+    udp?: IRustRouteUdp;
+}
+export interface IRustRouteConfig extends Omit<IRouteConfig, 'match' | 'action'> {
+    match: IRustRouteMatch;
+    action: IRustRouteAction;
+}
+export interface IRustAcmeOptions extends Omit<IAcmeOptions, 'routeForwards'> {
+}
+export interface IRustProxyOptions {
+    routes: IRustRouteConfig[];
+    preserveSourceIp?: boolean;
+    proxyIps?: string[];
+    acceptProxyProtocol?: boolean;
+    sendProxyProtocol?: boolean;
+    defaults?: IRustDefaultConfig;
+    connectionTimeout?: number;
+    initialDataTimeout?: number;
+    socketTimeout?: number;
+    inactivityCheckInterval?: number;
+    maxConnectionLifetime?: number;
+    inactivityTimeout?: number;
+    gracefulShutdownTimeout?: number;
+    noDelay?: boolean;
+    keepAlive?: boolean;
+    keepAliveInitialDelay?: number;
+    maxPendingDataSize?: number;
+    disableInactivityCheck?: boolean;
+    enableKeepAliveProbes?: boolean;
+    enableDetailedLogging?: boolean;
+    enableTlsDebugLogging?: boolean;
+    enableRandomizedTimeouts?: boolean;
+    maxConnectionsPerIp?: number;
+    connectionRateLimitPerMinute?: number;
+    keepAliveTreatment?: ISmartProxyOptions['keepAliveTreatment'];
+    keepAliveInactivityMultiplier?: number;
+    extendedKeepAliveLifetime?: number;
+    metrics?: ISmartProxyOptions['metrics'];
+    acme?: IRustAcmeOptions;
+}
+export interface IRustStatistics {
+    activeConnections: number;
+    totalConnections: number;
+    routesCount: number;
+    listeningPorts: number[];
+    uptimeSeconds: number;
+}
+export interface IRustCertificateStatus {
+    domain: string;
+    source: string;
+    expiresAt: number;
+    isValid: boolean;
+}
+export interface IRustThroughputSample {
+    timestampMs: number;
+    bytesIn: number;
+    bytesOut: number;
+}
+export interface IRustRouteMetrics {
+    activeConnections: number;
+    totalConnections: number;
+    bytesIn: number;
+    bytesOut: number;
+    throughputInBytesPerSec: number;
+    throughputOutBytesPerSec: number;
+    throughputRecentInBytesPerSec: number;
+    throughputRecentOutBytesPerSec: number;
+}
+export interface IRustIpMetrics {
+    activeConnections: number;
+    totalConnections: number;
+    bytesIn: number;
+    bytesOut: number;
+    throughputInBytesPerSec: number;
+    throughputOutBytesPerSec: number;
+    domainRequests: Record<string, number>;
+}
+export interface IRustBackendMetrics {
+    activeConnections: number;
+    totalConnections: number;
+    protocol: string;
+    connectErrors: number;
+    handshakeErrors: number;
+    requestErrors: number;
+    totalConnectTimeUs: number;
+    connectCount: number;
+    poolHits: number;
+    poolMisses: number;
+    h2Failures: number;
+}
+export interface IRustMetricsSnapshot {
+    activeConnections: number;
+    totalConnections: number;
+    bytesIn: number;
+    bytesOut: number;
+    throughputInBytesPerSec: number;
+    throughputOutBytesPerSec: number;
+    throughputRecentInBytesPerSec: number;
+    throughputRecentOutBytesPerSec: number;
+    routes: Record<string, IRustRouteMetrics>;
+    ips: Record<string, IRustIpMetrics>;
+    backends: Record<string, IRustBackendMetrics>;
+    throughputHistory: IRustThroughputSample[];
+    totalHttpRequests: number;
+    httpRequestsPerSec: number;
+    httpRequestsPerSecRecent: number;
+    activeUdpSessions: number;
+    totalUdpSessions: number;
+    totalDatagramsIn: number;
+    totalDatagramsOut: number;
+    detectedProtocols: IProtocolCacheEntry[];
+    frontendProtocols: IProtocolDistribution;
+    backendProtocols: IProtocolDistribution;
+}

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnVzdC10eXBlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3RzL3Byb3hpZXMvc21hcnQtcHJveHkvbW9kZWxzL3J1c3QtdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

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

@@ -1,4 +1,5 @@
 import type { IRouteConfig } from './models/route-types.js';
+import type { IRustRouteConfig } from './models/rust-types.js';
 /**
  * Preprocesses routes before sending them to Rust.
  *
@@ -21,7 +22,7 @@ export declare class RoutePreprocessor {
      * - Non-serializable fields are stripped
      * - Original routes are preserved in the local map for handler lookup
      */
-    preprocessForRust(routes: IRouteConfig[]): IRouteConfig[];
+    preprocessForRust(routes: IRouteConfig[]): IRustRouteConfig[];
     /**
      * Get the original route config (with JS functions) by route name or id.
      */

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

@@ -1,4 +1,4 @@
-import { logger } from '../../core/utils/logger.js';
+import { serializeRouteForRust } from './utils/rust-config.js';
 /**
  * Preprocesses routes before sending them to Rust.
  *
@@ -48,13 +48,13 @@ export class RoutePreprocessor {
         // Create a clean copy for Rust
         const cleanRoute = {
             ...route,
-            action: this.cleanAction(route.action, routeKey, needsTsHandling),
+            action: this.cleanAction(route.action, needsTsHandling),
         };
         // Ensure we have a name for handler lookup
         if (!cleanRoute.name && !cleanRoute.id) {
             cleanRoute.name = routeKey;
         }
-        return cleanRoute;
+        return serializeRouteForRust(cleanRoute);
     }
     routeNeedsTsHandling(route) {
         // Socket handler routes always need TS
@@ -75,14 +75,15 @@ export class RoutePreprocessor {
         }
         return false;
     }
-    cleanAction(action, routeKey, needsTsHandling) {
-        const cleanAction = { ...action };
+    cleanAction(action, needsTsHandling) {
+        let cleanAction = { ...action };
         if (needsTsHandling) {
             // Convert to socket-handler type for Rust (Rust will relay back to TS)
-            cleanAction.type = 'socket-handler';
-            // Remove the JS handlers (not serializable)
-            delete cleanAction.socketHandler;
-            delete cleanAction.datagramHandler;
+            const { socketHandler: _socketHandler, datagramHandler: _datagramHandler, ...serializableAction } = cleanAction;
+            cleanAction = {
+                ...serializableAction,
+                type: 'socket-handler',
+            };
         }
         // Clean targets - replace functions with static values
         if (cleanAction.targets) {
@@ -103,4 +104,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

@@ -32,6 +32,12 @@ export declare class RustMetricsAdapter implements IMetrics {
             ip: string;
             count: number;
         }>;
+        domainRequestsByIP: () => Map<string, Map<string, number>>;
+        topDomainRequests: (limit?: number) => Array<{
+            ip: string;
+            domain: string;
+            count: number;
+        }>;
         frontendProtocols: () => IProtocolDistribution;
         backendProtocols: () => IProtocolDistribution;
     };

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

@@ -83,6 +83,39 @@ export class RustMetricsAdapter {
             result.sort((a, b) => b.count - a.count);
             return result.slice(0, limit);
         },
+        domainRequestsByIP: () => {
+            const result = new Map();
+            if (this.cache?.ips) {
+                for (const [ip, im] of Object.entries(this.cache.ips)) {
+                    const dr = im.domainRequests;
+                    if (dr && typeof dr === 'object') {
+                        const domainMap = new Map();
+                        for (const [domain, count] of Object.entries(dr)) {
+                            domainMap.set(domain, count);
+                        }
+                        if (domainMap.size > 0) {
+                            result.set(ip, domainMap);
+                        }
+                    }
+                }
+            }
+            return result;
+        },
+        topDomainRequests: (limit = 20) => {
+            const result = [];
+            if (this.cache?.ips) {
+                for (const [ip, im] of Object.entries(this.cache.ips)) {
+                    const dr = im.domainRequests;
+                    if (dr && typeof dr === 'object') {
+                        for (const [domain, count] of Object.entries(dr)) {
+                            result.push({ ip, domain, count: count });
+                        }
+                    }
+                }
+            }
+            result.sort((a, b) => b.count - a.count);
+            return result.slice(0, limit);
+        },
         frontendProtocols: () => {
             const fp = this.cache?.frontendProtocols;
             return {
@@ -194,22 +227,21 @@ export class RustMetricsAdapter {
             const result = new Map();
             if (this.cache?.backends) {
                 for (const [key, bm] of Object.entries(this.cache.backends)) {
-                    const m = bm;
-                    const totalTimeUs = m.totalConnectTimeUs ?? 0;
-                    const count = m.connectCount ?? 0;
-                    const poolHits = m.poolHits ?? 0;
-                    const poolMisses = m.poolMisses ?? 0;
+                    const totalTimeUs = bm.totalConnectTimeUs ?? 0;
+                    const count = bm.connectCount ?? 0;
+                    const poolHits = bm.poolHits ?? 0;
+                    const poolMisses = bm.poolMisses ?? 0;
                     const poolTotal = poolHits + poolMisses;
                     result.set(key, {
-                        protocol: m.protocol ?? 'unknown',
-                        activeConnections: m.activeConnections ?? 0,
-                        totalConnections: m.totalConnections ?? 0,
-                        connectErrors: m.connectErrors ?? 0,
-                        handshakeErrors: m.handshakeErrors ?? 0,
-                        requestErrors: m.requestErrors ?? 0,
+                        protocol: bm.protocol ?? 'unknown',
+                        activeConnections: bm.activeConnections ?? 0,
+                        totalConnections: bm.totalConnections ?? 0,
+                        connectErrors: bm.connectErrors ?? 0,
+                        handshakeErrors: bm.handshakeErrors ?? 0,
+                        requestErrors: bm.requestErrors ?? 0,
                         avgConnectTimeMs: count > 0 ? (totalTimeUs / count) / 1000 : 0,
                         poolHitRate: poolTotal > 0 ? poolHits / poolTotal : 0,
-                        h2Failures: m.h2Failures ?? 0,
+                        h2Failures: bm.h2Failures ?? 0,
                     });
                 }
             }
@@ -228,8 +260,7 @@ export class RustMetricsAdapter {
             const result = [];
             if (this.cache?.backends) {
                 for (const [key, bm] of Object.entries(this.cache.backends)) {
-                    const m = bm;
-                    const errors = (m.connectErrors ?? 0) + (m.handshakeErrors ?? 0) + (m.requestErrors ?? 0);
+                    const errors = (bm.connectErrors ?? 0) + (bm.handshakeErrors ?? 0) + (bm.requestErrors ?? 0);
                     if (errors > 0)
                         result.push({ backend: key, errors });
                 }
@@ -259,4 +290,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":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rust-metrics-adapter.js","sourceRoot":"","sources":["../../../ts/proxies/smart-proxy/rust-metrics-adapter.ts"],"names":[],"mappings":"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"}

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

@@ -1,5 +1,5 @@
 import * as plugins from '../../plugins.js';
-import type { IRouteConfig } from './models/route-types.js';
+import type { IRustCertificateStatus, IRustMetricsSnapshot, IRustProxyOptions, IRustRouteConfig, IRustStatistics } from './models/rust-types.js';
 /**
  * Bridge between TypeScript SmartProxy and the Rust binary.
  * Wraps @push.rocks/smartrust's RustBridge with type-safe command definitions.
@@ -20,14 +20,14 @@ export declare class RustProxyBridge extends plugins.EventEmitter {
      * Whether the bridge is currently running.
      */
     get running(): boolean;
-    startProxy(config: any): Promise<void>;
+    startProxy(config: IRustProxyOptions): Promise<void>;
     stopProxy(): Promise<void>;
-    updateRoutes(routes: IRouteConfig[]): Promise<void>;
-    getMetrics(): Promise<any>;
-    getStatistics(): Promise<any>;
+    updateRoutes(routes: IRustRouteConfig[]): Promise<void>;
+    getMetrics(): Promise<IRustMetricsSnapshot>;
+    getStatistics(): Promise<IRustStatistics>;
     provisionCertificate(routeName: string): Promise<void>;
     renewCertificate(routeName: string): Promise<void>;
-    getCertificateStatus(routeName: string): Promise<any>;
+    getCertificateStatus(routeName: string): Promise<IRustCertificateStatus | null>;
     getListeningPorts(): Promise<number[]>;
     setSocketHandlerRelay(socketPath: string): Promise<void>;
     addListeningPort(port: number): Promise<void>;

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

@@ -129,4 +129,4 @@ export class RustProxyBridge extends plugins.EventEmitter {
         await this.bridge.sendCommand('setDatagramHandlerRelay', { socketPath });
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnVzdC1wcm94eS1icmlkZ2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9wcm94aWVzL3NtYXJ0LXByb3h5L3J1c3QtcHJveHktYnJpZGdlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0sa0JBQWtCLENBQUM7QUFDNUMsT0FBTyxFQUFFLE1BQU0sRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBdUJwRDs7O0dBR0c7QUFDSCxTQUFTLGNBQWM7SUFDckIsTUFBTSxPQUFPLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxhQUFhLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDO0lBQ2pGLE9BQU8sT0FBTyxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsT0FBTyxFQUFFLElBQUksRUFBRSxJQUFJLEVBQUUsSUFBSSxDQUFDLENBQUM7QUFDekQsQ0FBQztBQUVEOzs7R0FHRztBQUNILFNBQVMsdUJBQXVCO0lBQzlCLE1BQU0sT0FBTyxHQUEyQixFQUFFLEdBQUcsRUFBRSxPQUFPLEVBQUUsS0FBSyxFQUFFLE9BQU8sRUFBRSxDQUFDO0lBQ3pFLE1BQU0sS0FBSyxHQUEyQixFQUFFLEtBQUssRUFBRSxPQUFPLEVBQUUsTUFBTSxFQUFFLE9BQU8sRUFBRSxDQUFDO0lBQzFFLE1BQU0sRUFBRSxHQUFHLEtBQUssQ0FBQyxPQUFPLENBQUMsUUFBUSxDQUFDLENBQUM7SUFDbkMsTUFBTSxJQUFJLEdBQUcsT0FBTyxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUNuQyxJQUFJLEVBQUUsSUFBSSxJQUFJLEVBQUUsQ0FBQztRQUNmLE9BQU8sR0FBRyxFQUFFLElBQUksSUFBSSxFQUFFLENBQUM7SUFDekIsQ0FBQztJQUNELE9BQU8sSUFBSSxDQUFDO0FBQ2QsQ0FBQztBQUVEOzs7R0FHRztBQUNILFNBQVMsZUFBZTtJQUN0QixNQUFNLFdBQVcsR0FBRyxjQUFjLEVBQUUsQ0FBQztJQUNyQyxNQUFNLE1BQU0sR0FBRyx1QkFBdUIsRUFBRSxDQUFDO0lBQ3pDLE1BQU0sS0FBSyxHQUFhLEVBQUUsQ0FBQztJQUUzQix1REFBdUQ7SUFDdkQsSUFBSSxNQUFNLEVBQUUsQ0FBQztRQUNYLEtBQUssQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsV0FBVyxFQUFFLFdBQVcsRUFBRSxhQUFhLE1BQU0sRUFBRSxDQUFDLENBQUMsQ0FBQztJQUNqRixDQUFDO0lBQ0QsS0FBSyxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxXQUFXLEVBQUUsV0FBVyxFQUFFLFdBQVcsQ0FBQyxDQUFDLENBQUM7SUFFckUsd0JBQXdCO0lBQ3hCLEtBQUssQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsT0FBTyxDQUFDLEdBQUcsRUFBRSxFQUFFLE1BQU0sRUFBRSxRQUFRLEVBQUUsU0FBUyxFQUFFLFdBQVcsQ0FBQyxDQUFDLENBQUM7SUFDMUYsS0FBSyxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxPQUFPLENBQUMsR0FBRyxFQUFFLEVBQUUsTUFBTSxFQUFFLFFBQVEsRUFBRSxPQUFPLEVBQUUsV0FBVyxDQUFDLENBQUMsQ0FBQztJQUV4RixPQUFPLEtBQUssQ0FBQztBQUNmLENBQUM7QUFFRDs7O0dBR0c7QUFDSCxNQUFNLE9BQU8sZUFBZ0IsU0FBUSxPQUFPLENBQUMsWUFBWTtJQUMvQyxNQUFNLENBQW9EO0lBRWxFO1FBQ0UsS0FBSyxFQUFFLENBQUM7UUFFUixJQUFJLENBQUMsTUFBTSxHQUFHLElBQUksT0FBTyxDQUFDLFNBQVMsQ0FBQyxVQUFVLENBQXNCO1lBQ2xFLFVBQVUsRUFBRSxXQUFXO1lBQ3ZCLFVBQVUsRUFBRSx3QkFBd0I7WUFDcEMscUJBQXFCLEVBQUUsd0JBQXdCO1lBQy9DLFVBQVUsRUFBRSxlQUFlLEVBQUU7WUFDN0IsY0FBYyxFQUFFLEdBQUcsR0FBRyxJQUFJLEdBQUcsSUFBSSxFQUFFLHdEQUF3RDtZQUMzRixNQUFNLEVBQUU7Z0JBQ04sR0FBRyxFQUFFLENBQUMsS0FBYSxFQUFFLE9BQWUsRUFBRSxJQUEwQixFQUFFLEVBQUU7b0JBQ2xFLE1BQU0sQ0FBQyxHQUFHLENBQUMsS0FBWSxFQUFFLE9BQU8sRUFBRSxJQUFJLENBQUMsQ0FBQztnQkFDMUMsQ0FBQzthQUNGO1NBQ0YsQ0FBQyxDQUFDO1FBRUgsdUNBQXVDO1FBQ3ZDLElBQUksQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDLE1BQU0sRUFBRSxDQUFDLElBQW1CLEVBQUUsTUFBcUIsRUFBRSxFQUFFO1lBQ3BFLElBQUksQ0FBQyxJQUFJLENBQUMsTUFBTSxFQUFFLElBQUksRUFBRSxNQUFNLENBQUMsQ0FBQztRQUNsQyxDQUFDLENBQUMsQ0FBQztJQUNMLENBQUM7SUFFRDs7O09BR0c7SUFDSSxLQUFLLENBQUMsS0FBSztRQUNoQixPQUFPLElBQUksQ0FBQyxNQUFNLENBQUMsS0FBSyxFQUFFLENBQUM7SUFDN0IsQ0FBQztJQUVEOztPQUVHO0lBQ0ksSUFBSTtRQUNULElBQUksQ0FBQyxNQUFNLENBQUMsSUFBSSxFQUFFLENBQUM7SUFDckIsQ0FBQztJQUVEOztPQUVHO0lBQ0gsSUFBVyxPQUFPO1FBQ2hCLE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQyxPQUFPLENBQUM7SUFDN0IsQ0FBQztJQUVELDBEQUEwRDtJQUVuRCxLQUFLLENBQUMsVUFBVSxDQUFDLE1BQVc7UUFDakMsTUFBTSxJQUFJLENBQUMsTUFBTSxDQUFDLFdBQVcsQ0FBQyxPQUFPLEVBQUUsRUFBRSxNQUFNLEVBQUUsQ0FBQyxDQUFDO0lBQ3JELENBQUM7SUFFTSxLQUFLLENBQUMsU0FBUztRQUNwQixNQUFNLElBQUksQ0FBQyxNQUFNLENBQUMsV0FBVyxDQUFDLE1BQU0sRUFBRSxFQUEyQixDQUFDLENBQUM7SUFDckUsQ0FBQztJQUVNLEtBQUssQ0FBQyxZQUFZLENBQUMsTUFBc0I7UUFDOUMsTUFBTSxJQUFJLENBQUMsTUFBTSxDQUFDLFdBQVcsQ0FBQyxjQUFjLEVBQUUsRUFBRSxNQUFNLEVBQUUsQ0FBQyxDQUFDO0lBQzVELENBQUM7SUFFTSxLQUFLLENBQUMsVUFBVTtRQUNyQixPQUFPLElBQUksQ0FBQyxNQUFNLENBQUMsV0FBVyxDQUFDLFlBQVksRUFBRSxFQUEyQixDQUFDLENBQUM7SUFDNUUsQ0FBQztJQUVNLEtBQUssQ0FBQyxhQUFhO1FBQ3hCLE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQyxXQUFXLENBQUMsZUFBZSxFQUFFLEVBQTJCLENBQUMsQ0FBQztJQUMvRSxDQUFDO0lBRU0sS0FBSyxDQUFDLG9CQUFvQixDQUFDLFNBQWlCO1FBQ2pELE1BQU0sSUFBSSxDQUFDLE1BQU0sQ0FBQyxXQUFXLENBQUMsc0JBQXNCLEVBQUUsRUFBRSxTQUFTLEVBQUUsQ0FBQyxDQUFDO0lBQ3ZFLENBQUM7SUFFTSxLQUFLLENBQUMsZ0JBQWdCLENBQUMsU0FBaUI7UUFDN0MsTUFBTSxJQUFJLENBQUMsTUFBTSxDQUFDLFdBQVcsQ0FBQyxrQkFBa0IsRUFBRSxFQUFFLFNBQVMsRUFBRSxDQUFDLENBQUM7SUFDbkUsQ0FBQztJQUVNLEtBQUssQ0FBQyxvQkFBb0IsQ0FBQyxTQUFpQjtRQUNqRCxPQUFPLElBQUksQ0FBQyxNQUFNLENBQUMsV0FBVyxDQUFDLHNCQUFzQixFQUFFLEVBQUUsU0FBUyxFQUFFLENBQUMsQ0FBQztJQUN4RSxDQUFDO0lBRU0sS0FBSyxDQUFDLGlCQUFpQjtRQUM1QixNQUFNLE1BQU0sR0FBRyxNQUFNLElBQUksQ0FBQyxNQUFNLENBQUMsV0FBVyxDQUFDLG1CQUFtQixFQUFFLEVBQTJCLENBQUMsQ0FBQztRQUMvRixPQUFPLE1BQU0sRUFBRSxLQUFLLElBQUksRUFBRSxDQUFDO0lBQzdCLENBQUM7SUFFTSxLQUFLLENBQUMscUJBQXFCLENBQUMsVUFBa0I7UUFDbkQsTUFBTSxJQUFJLENBQUMsTUFBTSxDQUFDLFdBQVcsQ0FBQyx1QkFBdUIsRUFBRSxFQUFFLFVBQVUsRUFBRSxDQUFDLENBQUM7SUFDekUsQ0FBQztJQUVNLEtBQUssQ0FBQyxnQkFBZ0IsQ0FBQyxJQUFZO1FBQ3hDLE1BQU0sSUFBSSxDQUFDLE1BQU0sQ0FBQyxXQUFXLENBQUMsa0JBQWtCLEVBQUUsRUFBRSxJQUFJLEVBQUUsQ0FBQyxDQUFDO0lBQzlELENBQUM7SUFFTSxLQUFLLENBQUMsbUJBQW1CLENBQUMsSUFBWTtRQUMzQyxNQUFNLElBQUksQ0FBQyxNQUFNLENBQUMsV0FBVyxDQUFDLHFCQUFxQixFQUFFLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQztJQUNqRSxDQUFDO0lBRU0sS0FBSyxDQUFDLGVBQWUsQ0FBQyxNQUFjLEVBQUUsSUFBWSxFQUFFLEdBQVcsRUFBRSxFQUFXO1FBQ2pGLE1BQU0sSUFBSSxDQUFDLE1BQU0sQ0FBQyxXQUFXLENBQUMsaUJBQWlCLEVBQUUsRUFBRSxNQUFNLEVBQUUsSUFBSSxFQUFFLEdBQUcsRUFBRSxFQUFFLEVBQUUsQ0FBQyxDQUFDO0lBQzlFLENBQUM7SUFFTSxLQUFLLENBQUMsdUJBQXVCLENBQUMsVUFBa0I7UUFDckQsTUFBTSxJQUFJLENBQUMsTUFBTSxDQUFDLFdBQVcsQ0FBQyx5QkFBeUIsRUFBRSxFQUFFLFVBQVUsRUFBRSxDQUFDLENBQUM7SUFDM0UsQ0FBQztDQUNGIn0=
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -3,6 +3,7 @@ import { SharedRouteManager as RouteManager } from '../../core/routing/route-man
 import type { ISmartProxyOptions } from './models/interfaces.js';
 import type { IRouteConfig } from './models/route-types.js';
 import type { IMetrics } from './models/metrics-types.js';
+import type { IRustCertificateStatus, IRustStatistics } from './models/rust-types.js';
 /**
  * SmartProxy - Rust-backed proxy engine with TypeScript configuration API.
  *
@@ -50,7 +51,7 @@ export declare class SmartProxy extends plugins.EventEmitter {
     /**
      * Get certificate status for a route (async - calls Rust).
      */
-    getCertificateStatus(routeName: string): Promise<any>;
+    getCertificateStatus(routeName: string): Promise<IRustCertificateStatus | null>;
     /**
      * Get the metrics interface.
      */
@@ -58,7 +59,7 @@ export declare class SmartProxy extends plugins.EventEmitter {
     /**
      * Get statistics (async - calls Rust).
      */
-    getStatistics(): Promise<any>;
+    getStatistics(): Promise<IRustStatistics>;
     /**
      * Add a listening port at runtime.
      */