@push.rocks/smartproxy 27.6.0 → 27.7.0

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

@@ -140,12 +140,23 @@ export function routeMatchesHeaders(route, headers) {
     if (!route.match?.headers || Object.keys(route.match.headers).length === 0) {
         return true; // No headers specified means it matches any headers
     }
-    // Convert RegExp patterns to strings for HeaderMatcher
-    const stringHeaders = {};
-    for (const [key, value] of Object.entries(route.match.headers)) {
-        stringHeaders[key] = value instanceof RegExp ? value.source : value;
+    for (const [headerName, expectedValue] of Object.entries(route.match.headers)) {
+        const actualKey = Object.keys(headers).find((key) => key.toLowerCase() === headerName.toLowerCase());
+        const actualValue = actualKey ? headers[actualKey] : undefined;
+        if (actualValue === undefined) {
+            return false;
+        }
+        if (expectedValue instanceof RegExp) {
+            if (!expectedValue.test(actualValue)) {
+                return false;
+            }
+            continue;
+        }
+        if (!HeaderMatcher.match(expectedValue, actualValue)) {
+            return false;
+        }
     }
-    return HeaderMatcher.matchAll(stringHeaders, headers);
+    return true;
 }
 /**
  * Find all routes that match the given criteria
@@ -226,4 +237,4 @@ export function generateRouteId(route) {
 export function cloneRoute(route) {
     return JSON.parse(JSON.stringify(route));
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"route-utils.js","sourceRoot":"","sources":["../../../../ts/proxies/smart-proxy/utils/route-utils.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"route-utils.js","sourceRoot":"","sources":["../../../../ts/proxies/smart-proxy/utils/route-utils.ts"],"names":[],"mappings":"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"}

package/dist_ts/proxies/smart-proxy/utils/rust-config.d.ts

@@ -0,0 +1,11 @@
+import type { IAcmeOptions, ISmartProxyOptions } from '../models/interfaces.js';
+import type { IRouteAction, IRouteConfig, IRouteMatch, IRouteTarget, ITargetMatch } from '../models/route-types.js';
+import type { IRustProxyOptions, IRustRouteAction, IRustRouteConfig, IRustRouteMatch, IRustRouteTarget, IRustTargetMatch, TRustHeaderMatchers } from '../models/rust-types.js';
+export declare function serializeHeaderMatchValue(value: string | RegExp): string;
+export declare function serializeHeaderMatchers(headers?: Record<string, string | RegExp>): TRustHeaderMatchers | undefined;
+export declare function serializeTargetMatchForRust(match?: ITargetMatch): IRustTargetMatch | undefined;
+export declare function serializeRouteMatchForRust(match: IRouteMatch): IRustRouteMatch;
+export declare function serializeRouteTargetForRust(target: IRouteTarget): IRustRouteTarget;
+export declare function serializeRouteActionForRust(action: IRouteAction): IRustRouteAction;
+export declare function serializeRouteForRust(route: IRouteConfig): IRustRouteConfig;
+export declare function buildRustProxyOptions(settings: ISmartProxyOptions, routes: IRustRouteConfig[], acmeOverride?: IAcmeOptions): IRustProxyOptions;

package/dist_ts/proxies/smart-proxy/utils/rust-config.js

@@ -0,0 +1,133 @@
+const SUPPORTED_REGEX_FLAGS = new Set(['i', 'm', 's', 'u', 'g']);
+export function serializeHeaderMatchValue(value) {
+    if (typeof value === 'string') {
+        return value;
+    }
+    const unsupportedFlags = Array.from(new Set(value.flags)).filter((flag) => !SUPPORTED_REGEX_FLAGS.has(flag));
+    if (unsupportedFlags.length > 0) {
+        throw new Error(`Header RegExp uses unsupported flags for Rust serialization: ${unsupportedFlags.join(', ')}`);
+    }
+    return `/${value.source}/${value.flags}`;
+}
+export function serializeHeaderMatchers(headers) {
+    if (!headers) {
+        return undefined;
+    }
+    return Object.fromEntries(Object.entries(headers).map(([key, value]) => [key, serializeHeaderMatchValue(value)]));
+}
+export function serializeTargetMatchForRust(match) {
+    if (!match) {
+        return undefined;
+    }
+    return {
+        ...match,
+        headers: serializeHeaderMatchers(match.headers),
+    };
+}
+export function serializeRouteMatchForRust(match) {
+    return {
+        ...match,
+        headers: serializeHeaderMatchers(match.headers),
+    };
+}
+export function serializeRouteTargetForRust(target) {
+    if (typeof target.host !== 'string' && !Array.isArray(target.host)) {
+        throw new Error('Route target host must be serialized before sending to Rust');
+    }
+    if (typeof target.port !== 'number' && target.port !== 'preserve') {
+        throw new Error('Route target port must be serialized before sending to Rust');
+    }
+    return {
+        ...target,
+        host: target.host,
+        port: target.port,
+        match: serializeTargetMatchForRust(target.match),
+    };
+}
+function serializeUdpForRust(udp) {
+    if (!udp) {
+        return undefined;
+    }
+    const { maxSessionsPerIP, ...rest } = udp;
+    return {
+        ...rest,
+        maxSessionsPerIp: maxSessionsPerIP,
+    };
+}
+export function serializeRouteActionForRust(action) {
+    const { socketHandler: _socketHandler, datagramHandler: _datagramHandler, forwardingEngine: _forwardingEngine, nftables: _nftables, targets, udp, ...rest } = action;
+    return {
+        ...rest,
+        targets: targets?.map((target) => serializeRouteTargetForRust(target)),
+        udp: serializeUdpForRust(udp),
+    };
+}
+export function serializeRouteForRust(route) {
+    return {
+        ...route,
+        match: serializeRouteMatchForRust(route.match),
+        action: serializeRouteActionForRust(route.action),
+    };
+}
+function serializeAcmeForRust(acme) {
+    if (!acme) {
+        return undefined;
+    }
+    return {
+        enabled: acme.enabled,
+        email: acme.email,
+        environment: acme.environment,
+        accountEmail: acme.accountEmail,
+        port: acme.port,
+        useProduction: acme.useProduction,
+        renewThresholdDays: acme.renewThresholdDays,
+        autoRenew: acme.autoRenew,
+        skipConfiguredCerts: acme.skipConfiguredCerts,
+        renewCheckIntervalHours: acme.renewCheckIntervalHours,
+    };
+}
+function serializeDefaultsForRust(defaults) {
+    if (!defaults) {
+        return undefined;
+    }
+    const { preserveSourceIP, ...rest } = defaults;
+    return {
+        ...rest,
+        preserveSourceIp: preserveSourceIP,
+    };
+}
+export function buildRustProxyOptions(settings, routes, acmeOverride) {
+    const acme = acmeOverride !== undefined ? acmeOverride : settings.acme;
+    return {
+        routes,
+        preserveSourceIp: settings.preserveSourceIP,
+        proxyIps: settings.proxyIPs,
+        acceptProxyProtocol: settings.acceptProxyProtocol,
+        sendProxyProtocol: settings.sendProxyProtocol,
+        defaults: serializeDefaultsForRust(settings.defaults),
+        connectionTimeout: settings.connectionTimeout,
+        initialDataTimeout: settings.initialDataTimeout,
+        socketTimeout: settings.socketTimeout,
+        inactivityCheckInterval: settings.inactivityCheckInterval,
+        maxConnectionLifetime: settings.maxConnectionLifetime,
+        inactivityTimeout: settings.inactivityTimeout,
+        gracefulShutdownTimeout: settings.gracefulShutdownTimeout,
+        noDelay: settings.noDelay,
+        keepAlive: settings.keepAlive,
+        keepAliveInitialDelay: settings.keepAliveInitialDelay,
+        maxPendingDataSize: settings.maxPendingDataSize,
+        disableInactivityCheck: settings.disableInactivityCheck,
+        enableKeepAliveProbes: settings.enableKeepAliveProbes,
+        enableDetailedLogging: settings.enableDetailedLogging,
+        enableTlsDebugLogging: settings.enableTlsDebugLogging,
+        enableRandomizedTimeouts: settings.enableRandomizedTimeouts,
+        maxConnectionsPerIp: settings.maxConnectionsPerIP,
+        connectionRateLimitPerMinute: settings.connectionRateLimitPerMinute,
+        keepAliveTreatment: settings.keepAliveTreatment,
+        keepAliveInactivityMultiplier: settings.keepAliveInactivityMultiplier,
+        extendedKeepAliveLifetime: settings.extendedKeepAliveLifetime,
+        metrics: settings.metrics,
+        acme: serializeAcmeForRust(acme),
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnVzdC1jb25maWcuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi90cy9wcm94aWVzL3NtYXJ0LXByb3h5L3V0aWxzL3J1c3QtY29uZmlnLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQWVBLE1BQU0scUJBQXFCLEdBQUcsSUFBSSxHQUFHLENBQUMsQ0FBQyxHQUFHLEVBQUUsR0FBRyxFQUFFLEdBQUcsRUFBRSxHQUFHLEVBQUUsR0FBRyxDQUFDLENBQUMsQ0FBQztBQUVqRSxNQUFNLFVBQVUseUJBQXlCLENBQUMsS0FBc0I7SUFDOUQsSUFBSSxPQUFPLEtBQUssS0FBSyxRQUFRLEVBQUUsQ0FBQztRQUM5QixPQUFPLEtBQUssQ0FBQztJQUNmLENBQUM7SUFFRCxNQUFNLGdCQUFnQixHQUFHLEtBQUssQ0FBQyxJQUFJLENBQUMsSUFBSSxHQUFHLENBQUMsS0FBSyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsTUFBTSxDQUFDLENBQUMsSUFBSSxFQUFFLEVBQUUsQ0FBQyxDQUFDLHFCQUFxQixDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDO0lBQzdHLElBQUksZ0JBQWdCLENBQUMsTUFBTSxHQUFHLENBQUMsRUFBRSxDQUFDO1FBQ2hDLE1BQU0sSUFBSSxLQUFLLENBQ2IsZ0VBQWdFLGdCQUFnQixDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUM5RixDQUFDO0lBQ0osQ0FBQztJQUVELE9BQU8sSUFBSSxLQUFLLENBQUMsTUFBTSxJQUFJLEtBQUssQ0FBQyxLQUFLLEVBQUUsQ0FBQztBQUMzQyxDQUFDO0FBRUQsTUFBTSxVQUFVLHVCQUF1QixDQUFDLE9BQXlDO0lBQy9FLElBQUksQ0FBQyxPQUFPLEVBQUUsQ0FBQztRQUNiLE9BQU8sU0FBUyxDQUFDO0lBQ25CLENBQUM7SUFFRCxPQUFPLE1BQU0sQ0FBQyxXQUFXLENBQ3ZCLE1BQU0sQ0FBQyxPQUFPLENBQUMsT0FBTyxDQUFDLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxHQUFHLEVBQUUsS0FBSyxDQUFDLEVBQUUsRUFBRSxDQUFDLENBQUMsR0FBRyxFQUFFLHlCQUF5QixDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FDdkYsQ0FBQztBQUNKLENBQUM7QUFFRCxNQUFNLFVBQVUsMkJBQTJCLENBQUMsS0FBb0I7SUFDOUQsSUFBSSxDQUFDLEtBQUssRUFBRSxDQUFDO1FBQ1gsT0FBTyxTQUFTLENBQUM7SUFDbkIsQ0FBQztJQUVELE9BQU87UUFDTCxHQUFHLEtBQUs7UUFDUixPQUFPLEVBQUUsdUJBQXVCLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQztLQUNoRCxDQUFDO0FBQ0osQ0FBQztBQUVELE1BQU0sVUFBVSwwQkFBMEIsQ0FBQyxLQUFrQjtJQUMzRCxPQUFPO1FBQ0wsR0FBRyxLQUFLO1FBQ1IsT0FBTyxFQUFFLHVCQUF1QixDQUFDLEtBQUssQ0FBQyxPQUFPLENBQUM7S0FDaEQsQ0FBQztBQUNKLENBQUM7QUFFRCxNQUFNLFVBQVUsMkJBQTJCLENBQUMsTUFBb0I7SUFDOUQsSUFBSSxPQUFPLE1BQU0sQ0FBQyxJQUFJLEtBQUssUUFBUSxJQUFJLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQztRQUNuRSxNQUFNLElBQUksS0FBSyxDQUFDLDZEQUE2RCxDQUFDLENBQUM7SUFDakYsQ0FBQztJQUVELElBQUksT0FBTyxNQUFNLENBQUMsSUFBSSxLQUFLLFFBQVEsSUFBSSxNQUFNLENBQUMsSUFBSSxLQUFLLFVBQVUsRUFBRSxDQUFDO1FBQ2xFLE1BQU0sSUFBSSxLQUFLLENBQUMsNkRBQTZELENBQUMsQ0FBQztJQUNqRixDQUFDO0lBRUQsT0FBTztRQUNMLEdBQUcsTUFBTTtRQUNULElBQUksRUFBRSxNQUFNLENBQUMsSUFBSTtRQUNqQixJQUFJLEVBQUUsTUFBTSxDQUFDLElBQUk7UUFDakIsS0FBSyxFQUFFLDJCQUEyQixDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUM7S0FDakQsQ0FBQztBQUNKLENBQUM7QUFFRCxTQUFTLG1CQUFtQixDQUFDLEdBQXlCO0lBQ3BELElBQUksQ0FBQyxHQUFHLEVBQUUsQ0FBQztRQUNULE9BQU8sU0FBUyxDQUFDO0lBQ25CLENBQUM7SUFFRCxNQUFNLEVBQUUsZ0JBQWdCLEVBQUUsR0FBRyxJQUFJLEVBQUUsR0FBRyxHQUFHLENBQUM7SUFFMUMsT0FBTztRQUNMLEdBQUcsSUFBSTtRQUNQLGdCQUFnQixFQUFFLGdCQUFnQjtLQUNuQyxDQUFDO0FBQ0osQ0FBQztBQUVELE1BQU0sVUFBVSwyQkFBMkIsQ0FBQyxNQUFvQjtJQUM5RCxNQUFNLEVBQ0osYUFBYSxFQUFFLGNBQWMsRUFDN0IsZUFBZSxFQUFFLGdCQUFnQixFQUNqQyxnQkFBZ0IsRUFBRSxpQkFBaUIsRUFDbkMsUUFBUSxFQUFFLFNBQVMsRUFDbkIsT0FBTyxFQUNQLEdBQUcsRUFDSCxHQUFHLElBQUksRUFDUixHQUFHLE1BQU0sQ0FBQztJQUVYLE9BQU87UUFDTCxHQUFHLElBQUk7UUFDUCxPQUFPLEVBQUUsT0FBTyxFQUFFLEdBQUcsQ0FBQyxDQUFDLE1BQU0sRUFBRSxFQUFFLENBQUMsMkJBQTJCLENBQUMsTUFBTSxDQUFDLENBQUM7UUFDdEUsR0FBRyxFQUFFLG1CQUFtQixDQUFDLEdBQUcsQ0FBQztLQUM5QixDQUFDO0FBQ0osQ0FBQztBQUVELE1BQU0sVUFBVSxxQkFBcUIsQ0FBQyxLQUFtQjtJQUN2RCxPQUFPO1FBQ0wsR0FBRyxLQUFLO1FBQ1IsS0FBSyxFQUFFLDBCQUEwQixDQUFDLEtBQUssQ0FBQyxLQUFLLENBQUM7UUFDOUMsTUFBTSxFQUFFLDJCQUEyQixDQUFDLEtBQUssQ0FBQyxNQUFNLENBQUM7S0FDbEQsQ0FBQztBQUNKLENBQUM7QUFFRCxTQUFTLG9CQUFvQixDQUFDLElBQW1CO0lBQy9DLElBQUksQ0FBQyxJQUFJLEVBQUUsQ0FBQztRQUNWLE9BQU8sU0FBUyxDQUFDO0lBQ25CLENBQUM7SUFFRCxPQUFPO1FBQ0wsT0FBTyxFQUFFLElBQUksQ0FBQyxPQUFPO1FBQ3JCLEtBQUssRUFBRSxJQUFJLENBQUMsS0FBSztRQUNqQixXQUFXLEVBQUUsSUFBSSxDQUFDLFdBQVc7UUFDN0IsWUFBWSxFQUFFLElBQUksQ0FBQyxZQUFZO1FBQy9CLElBQUksRUFBRSxJQUFJLENBQUMsSUFBSTtRQUNmLGFBQWEsRUFBRSxJQUFJLENBQUMsYUFBYTtRQUNqQyxrQkFBa0IsRUFBRSxJQUFJLENBQUMsa0JBQWtCO1FBQzNDLFNBQVMsRUFBRSxJQUFJLENBQUMsU0FBUztRQUN6QixtQkFBbUIsRUFBRSxJQUFJLENBQUMsbUJBQW1CO1FBQzdDLHVCQUF1QixFQUFFLElBQUksQ0FBQyx1QkFBdUI7S0FDdEQsQ0FBQztBQUNKLENBQUM7QUFFRCxTQUFTLHdCQUF3QixDQUFDLFFBQXlDO0lBQ3pFLElBQUksQ0FBQyxRQUFRLEVBQUUsQ0FBQztRQUNkLE9BQU8sU0FBUyxDQUFDO0lBQ25CLENBQUM7SUFFRCxNQUFNLEVBQUUsZ0JBQWdCLEVBQUUsR0FBRyxJQUFJLEVBQUUsR0FBRyxRQUFRLENBQUM7SUFFL0MsT0FBTztRQUNMLEdBQUcsSUFBSTtRQUNQLGdCQUFnQixFQUFFLGdCQUFnQjtLQUNuQyxDQUFDO0FBQ0osQ0FBQztBQUVELE1BQU0sVUFBVSxxQkFBcUIsQ0FDbkMsUUFBNEIsRUFDNUIsTUFBMEIsRUFDMUIsWUFBMkI7SUFFM0IsTUFBTSxJQUFJLEdBQUcsWUFBWSxLQUFLLFNBQVMsQ0FBQyxDQUFDLENBQUMsWUFBWSxDQUFDLENBQUMsQ0FBQyxRQUFRLENBQUMsSUFBSSxDQUFDO0lBRXZFLE9BQU87UUFDTCxNQUFNO1FBQ04sZ0JBQWdCLEVBQUUsUUFBUSxDQUFDLGdCQUFnQjtRQUMzQyxRQUFRLEVBQUUsUUFBUSxDQUFDLFFBQVE7UUFDM0IsbUJBQW1CLEVBQUUsUUFBUSxDQUFDLG1CQUFtQjtRQUNqRCxpQkFBaUIsRUFBRSxRQUFRLENBQUMsaUJBQWlCO1FBQzdDLFFBQVEsRUFBRSx3QkFBd0IsQ0FBQyxRQUFRLENBQUMsUUFBUSxDQUFDO1FBQ3JELGlCQUFpQixFQUFFLFFBQVEsQ0FBQyxpQkFBaUI7UUFDN0Msa0JBQWtCLEVBQUUsUUFBUSxDQUFDLGtCQUFrQjtRQUMvQyxhQUFhLEVBQUUsUUFBUSxDQUFDLGFBQWE7UUFDckMsdUJBQXVCLEVBQUUsUUFBUSxDQUFDLHVCQUF1QjtRQUN6RCxxQkFBcUIsRUFBRSxRQUFRLENBQUMscUJBQXFCO1FBQ3JELGlCQUFpQixFQUFFLFFBQVEsQ0FBQyxpQkFBaUI7UUFDN0MsdUJBQXVCLEVBQUUsUUFBUSxDQUFDLHVCQUF1QjtRQUN6RCxPQUFPLEVBQUUsUUFBUSxDQUFDLE9BQU87UUFDekIsU0FBUyxFQUFFLFFBQVEsQ0FBQyxTQUFTO1FBQzdCLHFCQUFxQixFQUFFLFFBQVEsQ0FBQyxxQkFBcUI7UUFDckQsa0JBQWtCLEVBQUUsUUFBUSxDQUFDLGtCQUFrQjtRQUMvQyxzQkFBc0IsRUFBRSxRQUFRLENBQUMsc0JBQXNCO1FBQ3ZELHFCQUFxQixFQUFFLFFBQVEsQ0FBQyxxQkFBcUI7UUFDckQscUJBQXFCLEVBQUUsUUFBUSxDQUFDLHFCQUFxQjtRQUNyRCxxQkFBcUIsRUFBRSxRQUFRLENBQUMscUJBQXFCO1FBQ3JELHdCQUF3QixFQUFFLFFBQVEsQ0FBQyx3QkFBd0I7UUFDM0QsbUJBQW1CLEVBQUUsUUFBUSxDQUFDLG1CQUFtQjtRQUNqRCw0QkFBNEIsRUFBRSxRQUFRLENBQUMsNEJBQTRCO1FBQ25FLGtCQUFrQixFQUFFLFFBQVEsQ0FBQyxrQkFBa0I7UUFDL0MsNkJBQTZCLEVBQUUsUUFBUSxDQUFDLDZCQUE2QjtRQUNyRSx5QkFBeUIsRUFBRSxRQUFRLENBQUMseUJBQXlCO1FBQzdELE9BQU8sRUFBRSxRQUFRLENBQUMsT0FBTztRQUN6QixJQUFJLEVBQUUsb0JBQW9CLENBQUMsSUFBSSxDQUFDO0tBQ2pDLENBQUM7QUFDSixDQUFDIn0=

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/smartproxy",
-  "version": "27.6.0",
+  "version": "27.7.0",
   "private": false,
   "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.",
   "main": "dist_ts/index.js",

package/ts/00_commitinfo_data.ts

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

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

@@ -0,0 +1,160 @@
+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/ts/proxies/smart-proxy/route-preprocessor.ts

@@ -1,5 +1,6 @@
 import type { IRouteConfig, IRouteAction, IRouteTarget } from './models/route-types.js';
-import { logger } from '../../core/utils/logger.js';
+import type { IRustRouteConfig } from './models/rust-types.js';
+import { serializeRouteForRust } from './utils/rust-config.js';
 
 /**
  * Preprocesses routes before sending them to Rust.
@@ -24,7 +25,7 @@ export class RoutePreprocessor {
    * - Non-serializable fields are stripped
    * - Original routes are preserved in the local map for handler lookup
    */
-  public preprocessForRust(routes: IRouteConfig[]): IRouteConfig[] {
+  public preprocessForRust(routes: IRouteConfig[]): IRustRouteConfig[] {
     this.originalRoutes.clear();
     return routes.map((route, index) => this.preprocessRoute(route, index));
   }
@@ -43,7 +44,7 @@ export class RoutePreprocessor {
     return new Map(this.originalRoutes);
   }
 
-  private preprocessRoute(route: IRouteConfig, index: number): IRouteConfig {
+  private preprocessRoute(route: IRouteConfig, index: number): IRustRouteConfig {
     const routeKey = route.name || route.id || `route_${index}`;
 
     // Check if this route needs TS-side handling
@@ -57,7 +58,7 @@ export class RoutePreprocessor {
     // Create a clean copy for Rust
     const cleanRoute: IRouteConfig = {
       ...route,
-      action: this.cleanAction(route.action, routeKey, needsTsHandling),
+      action: this.cleanAction(route.action, needsTsHandling),
     };
 
     // Ensure we have a name for handler lookup
@@ -65,7 +66,7 @@ export class RoutePreprocessor {
       cleanRoute.name = routeKey;
     }
 
-    return cleanRoute;
+    return serializeRouteForRust(cleanRoute);
   }
 
   private routeNeedsTsHandling(route: IRouteConfig): boolean {
@@ -91,15 +92,16 @@ export class RoutePreprocessor {
     return false;
   }
 
-  private cleanAction(action: IRouteAction, routeKey: string, needsTsHandling: boolean): IRouteAction {
-    const cleanAction: IRouteAction = { ...action };
+  private cleanAction(action: IRouteAction, needsTsHandling: boolean): IRouteAction {
+    let cleanAction: IRouteAction = { ...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 as any).socketHandler;
-      delete (cleanAction as any).datagramHandler;
+      const { socketHandler: _socketHandler, datagramHandler: _datagramHandler, ...serializableAction } = cleanAction;
+      cleanAction = {
+        ...serializableAction,
+        type: 'socket-handler',
+      };
     }
 
     // Clean targets - replace functions with static values

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

@@ -1,5 +1,6 @@
 import type { IMetrics, IBackendMetrics, IProtocolCacheEntry, IProtocolDistribution, IThroughputData, IThroughputHistoryPoint } from './models/metrics-types.js';
 import type { RustProxyBridge } from './rust-proxy-bridge.js';
+import type { IRustBackendMetrics, IRustIpMetrics, IRustMetricsSnapshot, IRustRouteMetrics } from './models/rust-types.js';
 
 /**
  * Adapts Rust JSON metrics to the IMetrics interface.
@@ -14,7 +15,7 @@ import type { RustProxyBridge } from './rust-proxy-bridge.js';
  */
 export class RustMetricsAdapter implements IMetrics {
   private bridge: RustProxyBridge;
-  private cache: any = null;
+  private cache: IRustMetricsSnapshot | null = null;
   private pollTimer: ReturnType<typeof setInterval> | null = null;
   private pollIntervalMs: number;
 
@@ -65,8 +66,8 @@ export class RustMetricsAdapter implements IMetrics {
     byRoute: (): Map<string, number> => {
       const result = new Map<string, number>();
       if (this.cache?.routes) {
-        for (const [name, rm] of Object.entries(this.cache.routes)) {
-          result.set(name, (rm as any).activeConnections ?? 0);
+        for (const [name, rm] of Object.entries(this.cache.routes) as Array<[string, IRustRouteMetrics]>) {
+          result.set(name, rm.activeConnections ?? 0);
         }
       }
       return result;
@@ -74,8 +75,8 @@ export class RustMetricsAdapter implements IMetrics {
     byIP: (): Map<string, number> => {
       const result = new Map<string, number>();
       if (this.cache?.ips) {
-        for (const [ip, im] of Object.entries(this.cache.ips)) {
-          result.set(ip, (im as any).activeConnections ?? 0);
+        for (const [ip, im] of Object.entries(this.cache.ips) as Array<[string, IRustIpMetrics]>) {
+          result.set(ip, im.activeConnections ?? 0);
         }
       }
       return result;
@@ -83,8 +84,8 @@ export class RustMetricsAdapter implements IMetrics {
     topIPs: (limit: number = 10): Array<{ ip: string; count: number }> => {
       const result: Array<{ ip: string; count: number }> = [];
       if (this.cache?.ips) {
-        for (const [ip, im] of Object.entries(this.cache.ips)) {
-          result.push({ ip, count: (im as any).activeConnections ?? 0 });
+        for (const [ip, im] of Object.entries(this.cache.ips) as Array<[string, IRustIpMetrics]>) {
+          result.push({ ip, count: im.activeConnections ?? 0 });
         }
       }
       result.sort((a, b) => b.count - a.count);
@@ -93,8 +94,8 @@ export class RustMetricsAdapter implements IMetrics {
     domainRequestsByIP: (): Map<string, Map<string, number>> => {
       const result = new Map<string, Map<string, number>>();
       if (this.cache?.ips) {
-        for (const [ip, im] of Object.entries(this.cache.ips)) {
-          const dr = (im as any).domainRequests;
+        for (const [ip, im] of Object.entries(this.cache.ips) as Array<[string, IRustIpMetrics]>) {
+          const dr = im.domainRequests;
           if (dr && typeof dr === 'object') {
             const domainMap = new Map<string, number>();
             for (const [domain, count] of Object.entries(dr)) {
@@ -111,8 +112,8 @@ export class RustMetricsAdapter implements IMetrics {
     topDomainRequests: (limit: number = 20): Array<{ ip: string; domain: string; count: number }> => {
       const result: Array<{ ip: string; domain: string; count: number }> = [];
       if (this.cache?.ips) {
-        for (const [ip, im] of Object.entries(this.cache.ips)) {
-          const dr = (im as any).domainRequests;
+        for (const [ip, im] of Object.entries(this.cache.ips) as Array<[string, IRustIpMetrics]>) {
+          const dr = im.domainRequests;
           if (dr && typeof dr === 'object') {
             for (const [domain, count] of Object.entries(dr)) {
               result.push({ ip, domain, count: count as number });
@@ -176,7 +177,7 @@ export class RustMetricsAdapter implements IMetrics {
     },
     history: (seconds: number): Array<IThroughputHistoryPoint> => {
       if (!this.cache?.throughputHistory) return [];
-      return this.cache.throughputHistory.slice(-seconds).map((p: any) => ({
+      return this.cache.throughputHistory.slice(-seconds).map((p) => ({
         timestamp: p.timestampMs,
         in: p.bytesIn,
         out: p.bytesOut,
@@ -185,10 +186,10 @@ export class RustMetricsAdapter implements IMetrics {
     byRoute: (_windowSeconds?: number): Map<string, IThroughputData> => {
       const result = new Map<string, IThroughputData>();
       if (this.cache?.routes) {
-        for (const [name, rm] of Object.entries(this.cache.routes)) {
+        for (const [name, rm] of Object.entries(this.cache.routes) as Array<[string, IRustRouteMetrics]>) {
           result.set(name, {
-            in: (rm as any).throughputInBytesPerSec ?? 0,
-            out: (rm as any).throughputOutBytesPerSec ?? 0,
+            in: rm.throughputInBytesPerSec ?? 0,
+            out: rm.throughputOutBytesPerSec ?? 0,
           });
         }
       }
@@ -197,10 +198,10 @@ export class RustMetricsAdapter implements IMetrics {
     byIP: (_windowSeconds?: number): Map<string, IThroughputData> => {
       const result = new Map<string, IThroughputData>();
       if (this.cache?.ips) {
-        for (const [ip, im] of Object.entries(this.cache.ips)) {
+        for (const [ip, im] of Object.entries(this.cache.ips) as Array<[string, IRustIpMetrics]>) {
           result.set(ip, {
-            in: (im as any).throughputInBytesPerSec ?? 0,
-            out: (im as any).throughputOutBytesPerSec ?? 0,
+            in: im.throughputInBytesPerSec ?? 0,
+            out: im.throughputOutBytesPerSec ?? 0,
           });
         }
       }
@@ -236,23 +237,22 @@ export class RustMetricsAdapter implements IMetrics {
     byBackend: (): Map<string, IBackendMetrics> => {
       const result = new Map<string, IBackendMetrics>();
       if (this.cache?.backends) {
-        for (const [key, bm] of Object.entries(this.cache.backends)) {
-          const m = bm as any;
-          const totalTimeUs = m.totalConnectTimeUs ?? 0;
-          const count = m.connectCount ?? 0;
-          const poolHits = m.poolHits ?? 0;
-          const poolMisses = m.poolMisses ?? 0;
+        for (const [key, bm] of Object.entries(this.cache.backends) as Array<[string, IRustBackendMetrics]>) {
+          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,
           });
         }
       }
@@ -261,8 +261,8 @@ export class RustMetricsAdapter implements IMetrics {
     protocols: (): Map<string, string> => {
       const result = new Map<string, string>();
       if (this.cache?.backends) {
-        for (const [key, bm] of Object.entries(this.cache.backends)) {
-          result.set(key, (bm as any).protocol ?? 'unknown');
+        for (const [key, bm] of Object.entries(this.cache.backends) as Array<[string, IRustBackendMetrics]>) {
+          result.set(key, bm.protocol ?? 'unknown');
         }
       }
       return result;
@@ -270,9 +270,8 @@ export class RustMetricsAdapter implements IMetrics {
     topByErrors: (limit: number = 10): Array<{ backend: string; errors: number }> => {
       const result: Array<{ backend: string; errors: number }> = [];
       if (this.cache?.backends) {
-        for (const [key, bm] of Object.entries(this.cache.backends)) {
-          const m = bm as any;
-          const errors = (m.connectErrors ?? 0) + (m.handshakeErrors ?? 0) + (m.requestErrors ?? 0);
+        for (const [key, bm] of Object.entries(this.cache.backends) as Array<[string, IRustBackendMetrics]>) {
+          const errors = (bm.connectErrors ?? 0) + (bm.handshakeErrors ?? 0) + (bm.requestErrors ?? 0);
           if (errors > 0) result.push({ backend: key, errors });
         }
       }