@push.rocks/smartproxy 30.0.1 → 31.0.0

package/dist_rust/rustproxy_linux_arm64_musl.tsrust-build.json

@@ -1,13 +1,13 @@
 {
   "format": "tsrust.build-provenance.v2",
-  "binarySha256": "21db1d1ac89025fbded33251113db7f9ba5340ac32adfb5cf667e079258970ca",
+  "binarySha256": "12283928ad30dc9b9eded4cfe936e1fa1f3a09319ed63116894799024252a0aa",
   "buildInfo": {
     "projectName": "@push.rocks/smartproxy",
-    "projectVersion": "30.0.1",
-    "gitCommit": "9b7161fdf800b77284a4589f491ab4de149cd0b7",
+    "projectVersion": "31.0.0",
+    "gitCommit": "bc65e0a56653d666082bedf6ffeeb020465e73a9",
     "gitDirty": false,
-    "builtAt": "2026-10-13T21:08:30.672Z",
-    "tsrustVersion": "4.5.1",
+    "builtAt": "2026-10-20T18:54:52.852Z",
+    "tsrustVersion": "1.1.1",
     "binary": "rustproxy",
     "target": "linux_arm64_musl"
   }

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@push.rocks/smartproxy',
-    version: '30.0.1',
+    version: '31.0.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/index.d.ts

@@ -3,7 +3,7 @@
  */
 export { SmartProxy } from './proxies/smart-proxy/index.js';
 export { SharedRouteManager as RouteManager } from './core/routing/route-manager.js';
-export type { ISmartProxyOptions, ISmartProxySecurityPolicy, ISmartProxyChallengeOptions, IConnectionRecord, IRouteConfig, IRouteMatch, IRouteAction, IRouteFixedResponse, IRouteTls, IRouteContext, TDatagramHandler, IDatagramInfo, IActiveConnectionSnapshot, IActiveConnectionSnapshotOptions, IActiveConnectionSnapshotPage } from './proxies/smart-proxy/models/index.js';
+export type { ISmartProxyOptions, ISmartProxySecurityPolicy, ISmartProxyChallengeOptions, IConnectionRecord, IRouteConfig, IRouteMatch, IRouteAction, IRouteFixedResponse, IRouteTls, IRouteBackendTls, IRouteContext, TDatagramHandler, IDatagramInfo, IActiveConnectionSnapshot, IActiveConnectionSnapshotOptions, IActiveConnectionSnapshotPage } from './proxies/smart-proxy/models/index.js';
 export type { TSmartProxyCertProvisionObject, ICertProvisionEventComms, ICertificateIssuedEvent, ICertificateFailedEvent } from './proxies/smart-proxy/models/interfaces.js';
 export * from './proxies/smart-proxy/utils/index.js';
 export * from './core/models/common-types.js';

package/dist_ts/proxies/index.d.ts

@@ -4,4 +4,4 @@
 export { SmartProxy } from './smart-proxy/index.js';
 export { SharedRouteManager as SmartProxyRouteManager } from '../core/routing/route-manager.js';
 export * from './smart-proxy/utils/index.js';
-export type { ISmartProxyOptions, IConnectionRecord, IRouteConfig, IRouteMatch, IRouteAction, IRouteTls, IRouteContext } from './smart-proxy/models/index.js';
+export type { ISmartProxyOptions, IConnectionRecord, IRouteConfig, IRouteMatch, IRouteAction, IRouteTls, IRouteBackendTls, IRouteContext } from './smart-proxy/models/index.js';

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

@@ -30,7 +30,7 @@ export interface ISmartProxyCertStore {
     /** Remove a cert (optional) */
     remove?: (domain: string) => Promise<void>;
 }
-import type { IRouteConfig } from './route-types.js';
+import type { IRouteBackendTls, IRouteConfig } from './route-types.js';
 export interface ISmartProxySecurityPolicy {
     blockedIps?: string[];
     blockedCidrs?: string[];
@@ -131,6 +131,11 @@ export interface ISmartProxyOptions {
     preserveSourceIP?: boolean;
     trustedProxyIPs?: string[];
     sendProxyProtocol?: boolean;
+    /**
+     * Default verification of TLS backends; a route's or target's `tls.backend` replaces it.
+     * `serverName` belongs to routes and targets.
+     */
+    backendTls?: Omit<IRouteBackendTls, 'serverName'>;
     defaults?: {
         target?: {
             host: string;
@@ -171,8 +176,16 @@ export interface ISmartProxyOptions {
     enableDetailedLogging?: boolean;
     enableTlsDebugLogging?: boolean;
     enableRandomizedTimeouts?: boolean;
-    maxConnectionsPerIP?: number;
-    connectionRateLimitPerMinute?: number;
+    /**
+     * Maximum simultaneous connections from a single source IP. Omitted: 100. `null`: no per-IP
+     * limit. Must be a positive integer otherwise; 0 and negative values are refused.
+     */
+    maxConnectionsPerIP?: number | null;
+    /**
+     * Maximum new connections per minute from a single source IP. Omitted: 300. `null`: no per-IP
+     * rate limit. Must be a positive integer otherwise; 0 and negative values are refused.
+     */
+    connectionRateLimitPerMinute?: number | null;
     securityPolicy?: ISmartProxySecurityPolicy;
     /** Runtime-only challenge enforcement settings. Never store this in route configs. */
     challenge?: ISmartProxyChallengeOptions;

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

@@ -102,6 +102,29 @@ export interface IRouteTls {
     ciphers?: string;
     honorCipherOrder?: boolean;
     sessionTimeout?: number;
+    backend?: IRouteBackendTls;
+}
+/**
+ * Verification of a TLS backend the proxy connects to.
+ *
+ * The whole object applies: a target's `tls.backend`, else the route's `action.tls.backend`,
+ * else the proxy-wide `backendTls`, else the system root store. Without `ca` or
+ * `rejectUnauthorized: false`, a self-signed or private-CA backend fails verification.
+ */
+export interface IRouteBackendTls {
+    /** `false` accepts any backend certificate (default: verify) */
+    rejectUnauthorized?: boolean;
+    /**
+     * PEM certificates that replace the system root store for this backend, like Node's `ca`.
+     * A certificate is trusted as an issuer, so a self-signed backend certificate must not be a
+     * CA certificate (`basicConstraints CA:TRUE`).
+     */
+    ca?: string;
+    /**
+     * Name sent as SNI and checked against the backend certificate. Defaults to the requested
+     * domain on routes with named domains, else the backend host.
+     */
+    serverName?: string;
 }
 /**
  * Authentication options
@@ -131,6 +154,10 @@ export interface IRouteSecurity {
     }>;
     ipBlockList?: string[];
     maxConnections?: number;
+    /**
+     * @deprecated Not supported: route validation refuses a route that sets it.
+     * Use basicAuth or jwtAuth.
+     */
     authentication?: IRouteAuthentication;
     rateLimit?: IRouteRateLimit;
     basicAuth?: {

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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm91dGUtdHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi90cy9wcm94aWVzL3NtYXJ0LXByb3h5L21vZGVscy9yb3V0ZS10eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssT0FBTyxNQUFNLHFCQUFxQixDQUFDO0FBNGUvQyxvRUFBb0UifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm91dGUtdHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi90cy9wcm94aWVzL3NtYXJ0LXByb3h5L21vZGVscy9yb3V0ZS10eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssT0FBTyxNQUFNLHFCQUFxQixDQUFDO0FBdWdCL0Msb0VBQW9FIn0=

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

@@ -45,6 +45,13 @@ export interface IRustRouteValidationErrorData {
     routes: IRustRouteValidationIssue[];
 }
 export interface IRustAcmeOptions extends Omit<IAcmeOptions, 'routeForwards'> {
+    /**
+     * Whether the engine orders certificates for `certificate: 'auto'` routes at start
+     * and renews them on its own timer (default: true). SmartProxy sets it to false when
+     * a `certProvisionFunction` owns provisioning: the engine then orders a certificate
+     * only when `provisionCertificate` asks for one.
+     */
+    autoProvision?: boolean;
 }
 export interface IRustChallengeOptions extends Required<Pick<ISmartProxyChallengeOptions, 'cookieSigningKey' | 'pendingCookieName' | 'clearanceCookieName' | 'reservedPathPrefix' | 'relaySocketPath' | 'relayTimeoutMs' | 'pendingTtlSeconds'>> {
 }
@@ -53,6 +60,7 @@ export interface IRustProxyOptions {
     preserveSourceIp?: boolean;
     trustedProxyIPs?: string[];
     sendProxyProtocol?: boolean;
+    backendTls?: ISmartProxyOptions['backendTls'];
     defaults?: IRustDefaultConfig;
     connectionTimeout?: number;
     initialDataTimeout?: number;
@@ -70,8 +78,10 @@ export interface IRustProxyOptions {
     enableDetailedLogging?: boolean;
     enableTlsDebugLogging?: boolean;
     enableRandomizedTimeouts?: boolean;
-    maxConnectionsPerIp?: number;
-    connectionRateLimitPerMinute?: number;
+    /** `null`: no per-IP limit (the engine's `None`). */
+    maxConnectionsPerIp?: number | null;
+    /** `null`: no per-IP rate limit (the engine's `None`). */
+    connectionRateLimitPerMinute?: number | null;
     keepAliveTreatment?: ISmartProxyOptions['keepAliveTreatment'];
     keepAliveInactivityMultiplier?: number;
     extendedKeepAliveLifetime?: number;
@@ -93,6 +103,12 @@ export interface IRustCertificateStatus {
     expiresAt: number;
     isValid: boolean;
 }
+/** A certificate the engine ordered through ACME and now serves. */
+export interface IRustProvisionedCertificate {
+    domain: string;
+    /** The issued certificate chain in PEM; the private key stays in the engine. */
+    cert: string;
+}
 export interface IRustThroughputSample {
     timestampMs: number;
     bytesIn: number;

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

@@ -1,5 +1,5 @@
 import * as plugins from '../../plugins.js';
-import { type IRustCertificateStatus, type IRustChallengeOptions, type IRustMetricsSnapshot, type IRustProxyOptions, type IRustMetricsHistory, type IRustRouteConfig, type IRustStatistics } from './models/rust-types.js';
+import { type IRustCertificateStatus, type IRustProvisionedCertificate, type IRustChallengeOptions, type IRustMetricsSnapshot, type IRustProxyOptions, type IRustMetricsHistory, type IRustRouteConfig, type IRustStatistics } from './models/rust-types.js';
 import type { IActiveConnectionSnapshot, IActiveConnectionSnapshotOptions, IActiveConnectionSnapshotPage, ISmartProxySecurityPolicy } from './models/interfaces.js';
 /**
  * Turn a Rust `ROUTE_VALIDATION` refusal into a `RouteValidationError` carrying the
@@ -56,7 +56,12 @@ export declare class RustProxyBridge extends plugins.EventEmitter {
     getStatistics(): Promise<IRustStatistics>;
     getActiveConnectionSnapshots(options?: IActiveConnectionSnapshotOptions): Promise<IActiveConnectionSnapshot[]>;
     getActiveConnectionSnapshotPage(options?: IActiveConnectionSnapshotOptions): Promise<IActiveConnectionSnapshotPage>;
-    provisionCertificate(routeName: string): Promise<void>;
+    /**
+     * Order a certificate through the engine's ACME client: for `domain`, which the
+     * route must serve, or else for the route's first domain. `timeoutMs` overrides
+     * the bridge request timeout; an order can take minutes.
+     */
+    provisionCertificate(routeName: string, domain?: string, timeoutMs?: number): Promise<IRustProvisionedCertificate>;
     renewCertificate(routeName: string): Promise<void>;
     getCertificateStatus(routeName: string): Promise<IRustCertificateStatus | null>;
     getListeningPorts(): Promise<number[]>;

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

@@ -209,8 +209,13 @@ export class RustProxyBridge extends plugins.EventEmitter {
         validateActiveConnectionSnapshotOptions(options);
         return this.bridge.sendCommand('getActiveConnectionSnapshotPage', options);
     }
-    async provisionCertificate(routeName) {
-        await this.bridge.sendCommand('provisionCertificate', { routeName });
+    /**
+     * Order a certificate through the engine's ACME client: for `domain`, which the
+     * route must serve, or else for the route's first domain. `timeoutMs` overrides
+     * the bridge request timeout; an order can take minutes.
+     */
+    async provisionCertificate(routeName, domain, timeoutMs) {
+        return this.bridge.sendCommand('provisionCertificate', { routeName, domain }, { timeoutMs });
     }
     async renewCertificate(routeName) {
         await this.bridge.sendCommand('renewCertificate', { routeName });
@@ -241,4 +246,4 @@ export class RustProxyBridge extends plugins.EventEmitter {
         await this.bridge.sendCommand('setDatagramHandlerRelay', { socketPath });
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rust-proxy-bridge.js","sourceRoot":"","sources":["../../../ts/proxies/smart-proxy/rust-proxy-bridge.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rust-proxy-bridge.js","sourceRoot":"","sources":["../../../ts/proxies/smart-proxy/rust-proxy-bridge.ts"],"names":[],"mappings":"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"}

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

@@ -130,9 +130,17 @@ export declare class SmartProxy extends plugins.EventEmitter {
     getNfTablesStatus(): plugins.smartnftables.INftStatus | null;
     private cleanupRuntimeResourcesAfterStartFailure;
     /**
-     * Apply NFTables rules for routes using the nftables forwarding engine.
+     * Replace the current NFTables rules with those of `routes`. When a rule fails, the
+     * rules of `fallbackRoutes` are applied again before the error is rethrown.
+     */
+    private replaceNftablesRules;
+    /**
+     * Apply NFTables rules for the enabled routes using the nftables forwarding engine.
+     * A rule that fails removes the rules applied before it.
      */
     private applyNftablesRules;
+    /** Add the port-forwarding rules of each route, one per listed port and target. */
+    private addNftablesRules;
     /**
      * Build the Rust configuration object from TS settings.
      */
@@ -162,6 +170,7 @@ export declare class SmartProxy extends plugins.EventEmitter {
     /**
      * Record the validity window of a certificate loaded into Rust.
      * Prefers an explicit validUntil; otherwise parses the PEM.
+     * @returns the recorded end of validity, or undefined if it is unknown
      */
     private recordCertValidity;
     /** Whether the domain has a loaded cert that is not yet inside the renewal window. */
@@ -180,6 +189,14 @@ export declare class SmartProxy extends plugins.EventEmitter {
      * Includes per-domain timeout and shutdown checks.
      */
     private provisionSingleDomain;
+    /**
+     * Order a domain's certificate through the engine's ACME client (HTTP-01 on
+     * `acme.port`), for an 'http01' callback result or the ACME fallback. The engine
+     * serves the certificate; its recorded validity lets sweeps skip the domain until
+     * the renewal window.
+     * @returns the certificate's expiry date (ISO 8601), if its PEM parses
+     */
+    private provisionThroughRustAcme;
     /**
      * Race a promise against a timeout. Rejects with the given message if the timeout fires first.
      */