@push.rocks/smartproxy 27.15.1 → 27.16.0

package/.smartconfig.json

@@ -50,6 +50,7 @@
     "targets": [
       "linux_amd64",
       "linux_arm64"
-    ]
+    ],
+    "static": true
   }
 }

package/changelog.md

@@ -1,5 +1,32 @@
 # Changelog
 
+## 2026-06-10 - 27.16.0
+
+### Features
+
+- add per-domain failure cooldown for certificate provisioning (smart-proxy)
+  - New certProvisionFailureCooldownMs option (default 30 minutes): sweeps skip domains whose last provisioning attempt failed within the window, so permanently failing domains cannot generate continuous ACME orders.
+- run periodic certificate renewal sweeps (smart-proxy)
+  - A renewal sweep now runs every acme.renewCheckIntervalHours (default 24h, clamped to the max timer delay), so near-expiry callback-provisioned certificates renew even when routes never change.
+
+### Fixes
+
+- stop re-provisioning valid certificates on every route update (smart-proxy)
+  - Track each loaded certificate's validity (explicit validUntil or parsed from PEM) and skip provisioning for domains whose certificate is valid beyond acme.renewThresholdDays.
+  - Coalesce provisioning sweeps: at most one in flight plus one queued follow-up, replacing unbounded fire-and-forget sweep stacking from updateRoutes.
+  - Store-loaded certificates are skipped by validity instead of blindly, so near-expiry stored certificates renew at startup.
+  - Prune validity/cooldown tracking for domains that leave the route config.
+- warn with the caller stack when updateRoutes is called at loop-like rates (more than 12 calls per minute) to surface route update feedback loops.
+
+## 2026-06-09 - 27.15.2
+
+### Fixes
+
+- configure static Rust binary builds via tsrust (rust)
+  - Enabled static Rust binary builds through .smartconfig.json and updated @git.zone/tsrust to ^1.4.1.
+  - Removed repo-wide linux-gnu rustflags from Cargo config so cargo test and cargo check remain usable.
+  - Added a test:rust script and documented static linkage behavior.
+
 ## 2026-06-09 - 27.15.1
 
 ### Fixes

package/dist_ts/00_commitinfo_data.js

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

@@ -204,6 +204,13 @@ export interface ISmartProxyOptions {
      * Default: 4
      */
     certProvisionConcurrency?: number;
+    /**
+     * Per-domain cooldown in ms after a failed certificate provisioning attempt.
+     * Provisioning sweeps skip a domain while its cooldown is active, so a
+     * permanently failing domain cannot generate continuous ACME orders.
+     * Default: 1800000 (30 minutes)
+     */
+    certProvisionFailureCooldownMs?: number;
     /**
      * Disable the default self-signed fallback certificate.
      * When false (default), a self-signed cert is generated at startup and loaded

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

@@ -30,6 +30,15 @@ export declare class SmartProxy extends plugins.EventEmitter {
     private routeUpdateLock;
     private stopping;
     private certProvisionPromise;
+    private certProvisionQueued;
+    /** domain -> certificate validUntil (epoch ms) for certs currently loaded in Rust. */
+    private certValidity;
+    /** domain -> timestamp of the last failed provisioning attempt (cooldown anchor). */
+    private certFailureAt;
+    private renewalTimer;
+    /** updateRoutes call timestamps within the last minute, for loop detection. */
+    private routeUpdateTimestamps;
+    private lastRouteUpdateRateWarnAt;
     constructor(settingsArg: ISmartProxyOptions);
     /**
      * Register a runtime challenge provider family. Routes reference providerId + challengeType;
@@ -115,6 +124,29 @@ export declare class SmartProxy extends plugins.EventEmitter {
     private isPlainRecord;
     private collectForbiddenChallengeKeys;
     private looksLikeRuntimeChallengeValue;
+    /**
+     * Schedule a certificate provisioning sweep, coalescing with any sweep
+     * already in flight: at most one sweep runs at a time, plus at most one
+     * queued follow-up. Replaces unbounded fire-and-forget sweep stacking,
+     * which under repeated updateRoutes calls produced overlapping sweeps and
+     * continuous re-provisioning.
+     */
+    private kickCertProvisioning;
+    /**
+     * Warn (with caller stack) when updateRoutes is called at loop-like rates.
+     * A healthy deployment updates routes on config changes only; anything
+     * beyond a dozen calls per minute indicates a feedback loop upstream.
+     */
+    private trackRouteUpdateRate;
+    /**
+     * Record the validity window of a certificate loaded into Rust.
+     * Prefers an explicit validUntil; otherwise parses the PEM.
+     */
+    private recordCertValidity;
+    /** Whether the domain has a loaded cert that is not yet inside the renewal window. */
+    private hasValidCert;
+    /** Whether the domain failed provisioning recently and is still cooling down. */
+    private isInFailureCooldown;
     /**
      * For routes with certificate: 'auto', call certProvisionFunction if set.
      * If the callback returns a cert object, load it into Rust.

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

@@ -39,6 +39,15 @@ export class SmartProxy extends plugins.EventEmitter {
     routeUpdateLock;
     stopping = false;
     certProvisionPromise = null;
+    certProvisionQueued = false;
+    /** domain -> certificate validUntil (epoch ms) for certs currently loaded in Rust. */
+    certValidity = new Map();
+    /** domain -> timestamp of the last failed provisioning attempt (cooldown anchor). */
+    certFailureAt = new Map();
+    renewalTimer = null;
+    /** updateRoutes call timestamps within the last minute, for loop detection. */
+    routeUpdateTimestamps = [];
+    lastRouteUpdateRateWarnAt = 0;
     constructor(settingsArg) {
         super();
         // Apply defaults
@@ -188,14 +197,14 @@ export class SmartProxy extends plugins.EventEmitter {
                     logger.log('warn', `Failed to generate default certificate: ${err.message}`, { component: 'smart-proxy' });
                 }
             }
-            // Load consumer-stored certificates
-            const preloadedDomains = new Set();
+            // Load consumer-stored certificates. Their parsed validity feeds the
+            // skip-valid filter, so unexpired stored certs are not re-provisioned.
             if (this.settings.certStore) {
                 try {
                     const stored = await this.settings.certStore.loadAll();
                     for (const entry of stored) {
                         await this.bridge.loadCertificate(entry.domain, entry.publicKey, entry.privateKey, entry.ca);
-                        preloadedDomains.add(entry.domain);
+                        this.recordCertValidity(entry.domain, entry.publicKey);
                     }
                     logger.log('info', `Loaded ${stored.length} certificate(s) from consumer store`, { component: 'smart-proxy' });
                 }
@@ -213,8 +222,19 @@ export class SmartProxy extends plugins.EventEmitter {
             logger.log('info', 'SmartProxy started (Rust engine)', { component: 'smart-proxy' });
             // Fire-and-forget cert provisioning — Rust engine is already running and serving traffic.
             // Events (certificate-issued / certificate-failed) fire independently per domain.
-            this.certProvisionPromise = this.provisionCertificatesViaCallback(preloadedDomains)
-                .catch((err) => logger.log('error', `Unexpected error in cert provisioning: ${err.message}`, { component: 'smart-proxy' }));
+            // Store-loaded certs are skipped via their recorded validity (not blindly),
+            // so near-expiry stored certs renew right at startup.
+            this.kickCertProvisioning();
+            // Periodic renewal sweeps. Without a timer, renewals would only happen
+            // when something calls updateRoutes(); near-expiry domains pass the
+            // skip-valid filter naturally. The delay is clamped to Node's max timer
+            // value — beyond 2^31-1 ms setInterval degrades to a 1ms hot loop.
+            const renewCheckIntervalHours = this.settings.acme?.renewCheckIntervalHours || 24;
+            const renewIntervalMs = Math.min(renewCheckIntervalHours * 3_600_000, 2 ** 31 - 1);
+            this.renewalTimer = setInterval(() => {
+                this.kickCertProvisioning();
+            }, renewIntervalMs);
+            this.renewalTimer.unref?.();
         }
         catch (err) {
             await this.cleanupRuntimeResourcesAfterStartFailure(didSpawn);
@@ -227,6 +247,12 @@ export class SmartProxy extends plugins.EventEmitter {
     async stop() {
         logger.log('info', 'SmartProxy shutting down...', { component: 'smart-proxy' });
         this.stopping = true;
+        // Stop periodic renewal sweeps and drop any queued follow-up sweep
+        if (this.renewalTimer) {
+            clearInterval(this.renewalTimer);
+            this.renewalTimer = null;
+        }
+        this.certProvisionQueued = false;
         // Wait for in-flight cert provisioning to bail out (it checks this.stopping)
         if (this.certProvisionPromise) {
             await this.certProvisionPromise;
@@ -271,6 +297,7 @@ export class SmartProxy extends plugins.EventEmitter {
      * Update routes atomically.
      */
     async updateRoutes(newRoutes) {
+        this.trackRouteUpdateRate();
         await this.routeUpdateLock.runExclusive(async () => {
             await this.validateChallengeRoutes(newRoutes);
             // Validate before starting relays so failed route updates do not leak runtime resources.
@@ -346,8 +373,9 @@ export class SmartProxy extends plugins.EventEmitter {
         });
         // Fire-and-forget cert provisioning outside the mutex — routes are already updated,
         // cert provisioning doesn't need the route update lock and may be slow.
-        this.certProvisionPromise = this.provisionCertificatesViaCallback()
-            .catch((err) => logger.log('error', `Unexpected error in cert provisioning after route update: ${err.message}`, { component: 'smart-proxy' }));
+        // Sweeps are coalesced: at most one in flight plus one queued follow-up,
+        // and domains with valid loaded certs are skipped entirely.
+        this.kickCertProvisioning();
     }
     /**
      * Update the global ingress security policy without changing routes.
@@ -694,6 +722,87 @@ export class SmartProxy extends plugins.EventEmitter {
             || /(?:^|\b)(?:\d{1,3}\.){3}\d{1,3}(?::\d+)?(?:\b|$)/.test(valueArg)
             || /^[a-z0-9.-]+:\d+$/i.test(valueArg);
     }
+    /**
+     * Schedule a certificate provisioning sweep, coalescing with any sweep
+     * already in flight: at most one sweep runs at a time, plus at most one
+     * queued follow-up. Replaces unbounded fire-and-forget sweep stacking,
+     * which under repeated updateRoutes calls produced overlapping sweeps and
+     * continuous re-provisioning.
+     */
+    kickCertProvisioning() {
+        if (this.stopping)
+            return;
+        if (this.certProvisionPromise) {
+            this.certProvisionQueued = true;
+            return;
+        }
+        this.certProvisionPromise = (async () => {
+            try {
+                await this.provisionCertificatesViaCallback();
+                while (this.certProvisionQueued && !this.stopping) {
+                    this.certProvisionQueued = false;
+                    await this.provisionCertificatesViaCallback();
+                }
+            }
+            catch (err) {
+                logger.log('error', `Unexpected error in cert provisioning: ${err.message}`, { component: 'smart-proxy' });
+            }
+            finally {
+                this.certProvisionPromise = null;
+            }
+        })();
+    }
+    /**
+     * Warn (with caller stack) when updateRoutes is called at loop-like rates.
+     * A healthy deployment updates routes on config changes only; anything
+     * beyond a dozen calls per minute indicates a feedback loop upstream.
+     */
+    trackRouteUpdateRate() {
+        const now = Date.now();
+        this.routeUpdateTimestamps.push(now);
+        while (this.routeUpdateTimestamps.length && this.routeUpdateTimestamps[0] < now - 60_000) {
+            this.routeUpdateTimestamps.shift();
+        }
+        if (this.routeUpdateTimestamps.length > 12 && now - this.lastRouteUpdateRateWarnAt > 60_000) {
+            this.lastRouteUpdateRateWarnAt = now;
+            logger.log('warn', `updateRoutes called ${this.routeUpdateTimestamps.length} times in the last 60s — possible route update loop. Caller stack: ${new Error().stack}`, { component: 'smart-proxy' });
+        }
+    }
+    /**
+     * Record the validity window of a certificate loaded into Rust.
+     * Prefers an explicit validUntil; otherwise parses the PEM.
+     */
+    recordCertValidity(domain, publicKeyPem, validUntil) {
+        let resolved = validUntil;
+        if (!resolved && publicKeyPem) {
+            try {
+                const x509 = new plugins.crypto.X509Certificate(publicKeyPem);
+                resolved = new Date(x509.validTo).getTime();
+            }
+            catch {
+                // Unparseable PEM — leave validity unknown so the domain re-provisions.
+            }
+        }
+        if (resolved && Number.isFinite(resolved)) {
+            this.certValidity.set(domain, resolved);
+        }
+    }
+    /** Whether the domain has a loaded cert that is not yet inside the renewal window. */
+    hasValidCert(domain, nowMs) {
+        const validUntil = this.certValidity.get(domain);
+        if (!validUntil)
+            return false;
+        const renewThresholdDays = this.settings.acme?.renewThresholdDays || 30;
+        return validUntil - nowMs > renewThresholdDays * 24 * 3_600_000;
+    }
+    /** Whether the domain failed provisioning recently and is still cooling down. */
+    isInFailureCooldown(domain, nowMs) {
+        const failedAt = this.certFailureAt.get(domain);
+        if (!failedAt)
+            return false;
+        const cooldownMs = this.settings.certProvisionFailureCooldownMs ?? 1_800_000;
+        return nowMs - failedAt < cooldownMs;
+    }
     /**
      * For routes with certificate: 'auto', call certProvisionFunction if set.
      * If the callback returns a cert object, load it into Rust.
@@ -703,9 +812,14 @@ export class SmartProxy extends plugins.EventEmitter {
         const provisionFn = this.settings.certProvisionFunction;
         if (!provisionFn)
             return;
-        // Phase 1: Collect all unique (domain, route) pairs that need provisioning
+        // Phase 1: Collect all unique (domain, route) pairs that need provisioning.
+        // Domains whose loaded cert is still comfortably valid are skipped, as are
+        // domains in failure cooldown — so sweeps only do real work.
         const seen = new Set(skipDomains);
         const tasks = [];
+        const nowMs = Date.now();
+        let skippedValid = 0;
+        let skippedCooldown = 0;
         for (const route of this.settings.routes) {
             if (route.action.tls?.certificate !== 'auto')
                 continue;
@@ -717,11 +831,30 @@ export class SmartProxy extends plugins.EventEmitter {
                 if (seen.has(domain))
                     continue;
                 seen.add(domain);
+                if (this.hasValidCert(domain, nowMs)) {
+                    skippedValid++;
+                    continue;
+                }
+                if (this.isInFailureCooldown(domain, nowMs)) {
+                    skippedCooldown++;
+                    continue;
+                }
                 tasks.push({ domain, route });
             }
         }
+        // Prune tracking state for domains that left the route config, so the
+        // maps stay bounded by the current domain set.
+        for (const domain of this.certValidity.keys()) {
+            if (!seen.has(domain))
+                this.certValidity.delete(domain);
+        }
+        for (const domain of this.certFailureAt.keys()) {
+            if (!seen.has(domain))
+                this.certFailureAt.delete(domain);
+        }
         if (tasks.length === 0)
             return;
+        logger.log('info', `Cert provisioning sweep: ${tasks.length} domain(s) to provision (${skippedValid} valid skipped, ${skippedCooldown} in cooldown)`, { component: 'smart-proxy' });
         // Phase 2: Process all domains in parallel with concurrency limit
         const concurrency = this.settings.certProvisionConcurrency ?? 4;
         const semaphore = new ConcurrencySemaphore(concurrency);
@@ -775,6 +908,8 @@ export class SmartProxy extends plugins.EventEmitter {
                     return;
                 const certObj = result;
                 await this.bridge.loadCertificate(domain, certObj.publicKey, certObj.privateKey, certObj.ca);
+                this.certFailureAt.delete(domain);
+                this.recordCertValidity(domain, certObj.publicKey, typeof certObj.validUntil === 'number' ? certObj.validUntil : undefined);
                 logger.log('info', `Certificate loaded via provision function for ${domain}`, { component: 'smart-proxy' });
                 // Persist to consumer store
                 if (this.settings.certStore?.save) {
@@ -794,6 +929,9 @@ export class SmartProxy extends plugins.EventEmitter {
         }
         catch (err) {
             logger.log('warn', `certProvisionFunction failed for ${domain}: ${err.message}`, { component: 'smart-proxy' });
+            // Start the per-domain failure cooldown so subsequent sweeps skip this
+            // domain instead of re-running ACME orders back to back.
+            this.certFailureAt.set(domain, Date.now());
             this.emit('certificate-failed', {
                 domain,
                 error: err.message,
@@ -865,4 +1003,4 @@ export class SmartProxy extends plugins.EventEmitter {
         return validDomainRegex.test(domain);
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"smart-proxy.js","sourceRoot":"","sources":["../../../ts/proxies/smart-proxy/smart-proxy.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"smart-proxy.js","sourceRoot":"","sources":["../../../ts/proxies/smart-proxy/smart-proxy.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/smartproxy",
-  "version": "27.15.1",
+  "version": "27.16.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",
@@ -11,7 +11,7 @@
   "devDependencies": {
     "@git.zone/tsbuild": "^4.4.2",
     "@git.zone/tsrun": "^2.0.4",
-    "@git.zone/tsrust": "^1.3.4",
+    "@git.zone/tsrust": "^1.4.1",
     "@git.zone/tstest": "^3.6.6",
     "@push.rocks/smartserve": "^2.0.4",
     "@types/node": "^25.9.1",
@@ -73,6 +73,7 @@
   "scripts": {
     "test:before": "(tsrust)",
     "test": "(tstest test/**/test*.ts --verbose --timeout 60 --logfile)",
+    "test:rust": "(cd rust && cargo test)",
     "build": "(tsbuild tsfolders) && (tsrust)",
     "format": "(gitzone format)",
     "buildDocs": "tsdoc"

package/readme.hints.md

@@ -552,3 +552,10 @@ This allows simple single-target passthrough setups to work with TLS session res
 - CLIENT_IP header parsing timeout (default: 2000ms)
 - Network congestion between SmartProxy and HttpProxy
 - Solution: Check localhost connectivity, increase timeout if needed
+
+## Static Rust Binaries
+
+- The Rust binaries in `dist_rust/` are statically linked (static-pie) via `"static": true` in the `@git.zone/tsrust` block of `.smartconfig.json` (tsrust >= 1.4.1). They run on both glibc (Debian/Ubuntu) and musl (Alpine) systems.
+- tsrust injects `RUSTFLAGS="-C target-feature=+crt-static"` only into its own per-target cargo invocations and verifies the result (no `PT_INTERP` ELF header). Keep `rust/.cargo/config.toml` free of `rustflags` entries: the injected env variable would replace them, and a repo-wide `rustflags` would also break plain `cargo test`/`cargo check` (proc-macros cannot build with `+crt-static` on linux-gnu without an explicit `--target`). The repo previously carried such `rustflags` lines; they were removed when the tsrust `static` option was adopted.
+- `pnpm run test:rust` runs the Rust unit tests; plain `cargo test` in `rust/` works as well.
+- Verify linkage manually with `ldd dist_rust/<binary>_linux_amd64` → "statically linked".

package/readme.md

@@ -796,12 +796,18 @@ const proxy = new SmartProxy({
 **Startup flow:**
 1. Rust engine starts
 2. Default self-signed `*` fallback cert is loaded (unless `disableDefaultCert: true`)
-3. `certStore.loadAll()` is called → all returned certs are loaded into the Rust TLS stack
-4. `certProvisionFunction` runs for any remaining `certificate: 'auto'` routes (skipping domains already loaded from the store)
+3. `certStore.loadAll()` is called → all returned certs are loaded into the Rust TLS stack, and their parsed expiry feeds the skip-valid filter
+4. `certProvisionFunction` runs for any remaining `certificate: 'auto'` routes
 5. After each successful provision, `certStore.save()` is called
 
 This means your second startup is instant — no re-provisioning needed for domains that already have valid certs in your store.
 
+**Provisioning sweeps are conservative:**
+- A sweep skips every domain whose loaded cert is still valid beyond `acme.renewThresholdDays` (default 30), so `updateRoutes()` does not re-provision unchanged domains.
+- Domains whose provisioning failed wait out `certProvisionFailureCooldownMs` (default 30 minutes) before the next attempt, so a permanently failing domain cannot generate continuous ACME orders.
+- Sweeps coalesce: at most one runs at a time plus one queued follow-up, no matter how often routes are updated.
+- A renewal sweep runs every `acme.renewCheckIntervalHours` (default 24h), so near-expiry certs renew even when routes never change.
+
 ## 🏛️ Architecture
 
 SmartProxy uses a hybrid **Rust + TypeScript** architecture:
@@ -1097,6 +1103,7 @@ interface ISmartProxyOptions {
   certProvisionFallbackToAcme?: boolean;    // Fall back to ACME on failure (default: true)
   certProvisionTimeout?: number;            // Timeout per provision call (ms)
   certProvisionConcurrency?: number;        // Max concurrent provisions
+  certProvisionFailureCooldownMs?: number;  // Per-domain cooldown after a failed provision (default: 1800000)
 
   // Consumer-managed certificate persistence (see "Consumer-Managed Certificate Storage")
   certStore?: ISmartProxyCertStore;

package/ts/00_commitinfo_data.ts

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

@@ -242,6 +242,14 @@ export interface ISmartProxyOptions {
    */
   certProvisionConcurrency?: number;
 
+  /**
+   * Per-domain cooldown in ms after a failed certificate provisioning attempt.
+   * Provisioning sweeps skip a domain while its cooldown is active, so a
+   * permanently failing domain cannot generate continuous ACME orders.
+   * Default: 1800000 (30 minutes)
+   */
+  certProvisionFailureCooldownMs?: number;
+
   /**
    * Disable the default self-signed fallback certificate.
    * When false (default), a self-signed cert is generated at startup and loaded

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

@@ -51,6 +51,15 @@ export class SmartProxy extends plugins.EventEmitter {
   private routeUpdateLock: Mutex;
   private stopping = false;
   private certProvisionPromise: Promise<void> | null = null;
+  private certProvisionQueued = false;
+  /** domain -> certificate validUntil (epoch ms) for certs currently loaded in Rust. */
+  private certValidity = new Map<string, number>();
+  /** domain -> timestamp of the last failed provisioning attempt (cooldown anchor). */
+  private certFailureAt = new Map<string, number>();
+  private renewalTimer: NodeJS.Timeout | null = null;
+  /** updateRoutes call timestamps within the last minute, for loop detection. */
+  private routeUpdateTimestamps: number[] = [];
+  private lastRouteUpdateRateWarnAt = 0;
 
   constructor(settingsArg: ISmartProxyOptions) {
     super();
@@ -235,14 +244,14 @@ export class SmartProxy extends plugins.EventEmitter {
         }
       }
 
-      // Load consumer-stored certificates
-      const preloadedDomains = new Set<string>();
+      // Load consumer-stored certificates. Their parsed validity feeds the
+      // skip-valid filter, so unexpired stored certs are not re-provisioned.
       if (this.settings.certStore) {
         try {
           const stored = await this.settings.certStore.loadAll();
           for (const entry of stored) {
             await this.bridge.loadCertificate(entry.domain, entry.publicKey, entry.privateKey, entry.ca);
-            preloadedDomains.add(entry.domain);
+            this.recordCertValidity(entry.domain, entry.publicKey);
           }
           logger.log('info', `Loaded ${stored.length} certificate(s) from consumer store`, { component: 'smart-proxy' });
         } catch (err) {
@@ -263,8 +272,20 @@ export class SmartProxy extends plugins.EventEmitter {
 
       // Fire-and-forget cert provisioning — Rust engine is already running and serving traffic.
       // Events (certificate-issued / certificate-failed) fire independently per domain.
-      this.certProvisionPromise = this.provisionCertificatesViaCallback(preloadedDomains)
-        .catch((err) => logger.log('error', `Unexpected error in cert provisioning: ${err.message}`, { component: 'smart-proxy' }));
+      // Store-loaded certs are skipped via their recorded validity (not blindly),
+      // so near-expiry stored certs renew right at startup.
+      this.kickCertProvisioning();
+
+      // Periodic renewal sweeps. Without a timer, renewals would only happen
+      // when something calls updateRoutes(); near-expiry domains pass the
+      // skip-valid filter naturally. The delay is clamped to Node's max timer
+      // value — beyond 2^31-1 ms setInterval degrades to a 1ms hot loop.
+      const renewCheckIntervalHours = this.settings.acme?.renewCheckIntervalHours || 24;
+      const renewIntervalMs = Math.min(renewCheckIntervalHours * 3_600_000, 2 ** 31 - 1);
+      this.renewalTimer = setInterval(() => {
+        this.kickCertProvisioning();
+      }, renewIntervalMs);
+      this.renewalTimer.unref?.();
     } catch (err) {
       await this.cleanupRuntimeResourcesAfterStartFailure(didSpawn);
       throw err;
@@ -278,6 +299,13 @@ export class SmartProxy extends plugins.EventEmitter {
     logger.log('info', 'SmartProxy shutting down...', { component: 'smart-proxy' });
     this.stopping = true;
 
+    // Stop periodic renewal sweeps and drop any queued follow-up sweep
+    if (this.renewalTimer) {
+      clearInterval(this.renewalTimer);
+      this.renewalTimer = null;
+    }
+    this.certProvisionQueued = false;
+
     // Wait for in-flight cert provisioning to bail out (it checks this.stopping)
     if (this.certProvisionPromise) {
       await this.certProvisionPromise;
@@ -330,6 +358,7 @@ export class SmartProxy extends plugins.EventEmitter {
    * Update routes atomically.
    */
   public async updateRoutes(newRoutes: IRouteConfig[]): Promise<void> {
+    this.trackRouteUpdateRate();
     await this.routeUpdateLock.runExclusive(async () => {
       await this.validateChallengeRoutes(newRoutes);
 
@@ -425,8 +454,9 @@ export class SmartProxy extends plugins.EventEmitter {
 
     // Fire-and-forget cert provisioning outside the mutex — routes are already updated,
     // cert provisioning doesn't need the route update lock and may be slow.
-    this.certProvisionPromise = this.provisionCertificatesViaCallback()
-      .catch((err) => logger.log('error', `Unexpected error in cert provisioning after route update: ${err.message}`, { component: 'smart-proxy' }));
+    // Sweeps are coalesced: at most one in flight plus one queued follow-up,
+    // and domains with valid loaded certs are skipped entirely.
+    this.kickCertProvisioning();
   }
 
   /**
@@ -851,6 +881,90 @@ export class SmartProxy extends plugins.EventEmitter {
       || /^[a-z0-9.-]+:\d+$/i.test(valueArg);
   }
 
+  /**
+   * Schedule a certificate provisioning sweep, coalescing with any sweep
+   * already in flight: at most one sweep runs at a time, plus at most one
+   * queued follow-up. Replaces unbounded fire-and-forget sweep stacking,
+   * which under repeated updateRoutes calls produced overlapping sweeps and
+   * continuous re-provisioning.
+   */
+  private kickCertProvisioning(): void {
+    if (this.stopping) return;
+    if (this.certProvisionPromise) {
+      this.certProvisionQueued = true;
+      return;
+    }
+    this.certProvisionPromise = (async () => {
+      try {
+        await this.provisionCertificatesViaCallback();
+        while (this.certProvisionQueued && !this.stopping) {
+          this.certProvisionQueued = false;
+          await this.provisionCertificatesViaCallback();
+        }
+      } catch (err: any) {
+        logger.log('error', `Unexpected error in cert provisioning: ${err.message}`, { component: 'smart-proxy' });
+      } finally {
+        this.certProvisionPromise = null;
+      }
+    })();
+  }
+
+  /**
+   * Warn (with caller stack) when updateRoutes is called at loop-like rates.
+   * A healthy deployment updates routes on config changes only; anything
+   * beyond a dozen calls per minute indicates a feedback loop upstream.
+   */
+  private trackRouteUpdateRate(): void {
+    const now = Date.now();
+    this.routeUpdateTimestamps.push(now);
+    while (this.routeUpdateTimestamps.length && this.routeUpdateTimestamps[0] < now - 60_000) {
+      this.routeUpdateTimestamps.shift();
+    }
+    if (this.routeUpdateTimestamps.length > 12 && now - this.lastRouteUpdateRateWarnAt > 60_000) {
+      this.lastRouteUpdateRateWarnAt = now;
+      logger.log(
+        'warn',
+        `updateRoutes called ${this.routeUpdateTimestamps.length} times in the last 60s — possible route update loop. Caller stack: ${new Error().stack}`,
+        { component: 'smart-proxy' },
+      );
+    }
+  }
+
+  /**
+   * Record the validity window of a certificate loaded into Rust.
+   * Prefers an explicit validUntil; otherwise parses the PEM.
+   */
+  private recordCertValidity(domain: string, publicKeyPem: string, validUntil?: number): void {
+    let resolved = validUntil;
+    if (!resolved && publicKeyPem) {
+      try {
+        const x509 = new plugins.crypto.X509Certificate(publicKeyPem);
+        resolved = new Date(x509.validTo).getTime();
+      } catch {
+        // Unparseable PEM — leave validity unknown so the domain re-provisions.
+      }
+    }
+    if (resolved && Number.isFinite(resolved)) {
+      this.certValidity.set(domain, resolved);
+    }
+  }
+
+  /** Whether the domain has a loaded cert that is not yet inside the renewal window. */
+  private hasValidCert(domain: string, nowMs: number): boolean {
+    const validUntil = this.certValidity.get(domain);
+    if (!validUntil) return false;
+    const renewThresholdDays = this.settings.acme?.renewThresholdDays || 30;
+    return validUntil - nowMs > renewThresholdDays * 24 * 3_600_000;
+  }
+
+  /** Whether the domain failed provisioning recently and is still cooling down. */
+  private isInFailureCooldown(domain: string, nowMs: number): boolean {
+    const failedAt = this.certFailureAt.get(domain);
+    if (!failedAt) return false;
+    const cooldownMs = this.settings.certProvisionFailureCooldownMs ?? 1_800_000;
+    return nowMs - failedAt < cooldownMs;
+  }
+
   /**
    * For routes with certificate: 'auto', call certProvisionFunction if set.
    * If the callback returns a cert object, load it into Rust.
@@ -860,9 +974,14 @@ export class SmartProxy extends plugins.EventEmitter {
     const provisionFn = this.settings.certProvisionFunction;
     if (!provisionFn) return;
 
-    // Phase 1: Collect all unique (domain, route) pairs that need provisioning
+    // Phase 1: Collect all unique (domain, route) pairs that need provisioning.
+    // Domains whose loaded cert is still comfortably valid are skipped, as are
+    // domains in failure cooldown — so sweeps only do real work.
     const seen = new Set<string>(skipDomains);
     const tasks: Array<{ domain: string; route: IRouteConfig }> = [];
+    const nowMs = Date.now();
+    let skippedValid = 0;
+    let skippedCooldown = 0;
 
     for (const route of this.settings.routes) {
       if (route.action.tls?.certificate !== 'auto') continue;
@@ -874,12 +993,35 @@ export class SmartProxy extends plugins.EventEmitter {
       for (const domain of certDomains) {
         if (seen.has(domain)) continue;
         seen.add(domain);
+        if (this.hasValidCert(domain, nowMs)) {
+          skippedValid++;
+          continue;
+        }
+        if (this.isInFailureCooldown(domain, nowMs)) {
+          skippedCooldown++;
+          continue;
+        }
         tasks.push({ domain, route });
       }
     }
 
+    // Prune tracking state for domains that left the route config, so the
+    // maps stay bounded by the current domain set.
+    for (const domain of this.certValidity.keys()) {
+      if (!seen.has(domain)) this.certValidity.delete(domain);
+    }
+    for (const domain of this.certFailureAt.keys()) {
+      if (!seen.has(domain)) this.certFailureAt.delete(domain);
+    }
+
     if (tasks.length === 0) return;
 
+    logger.log(
+      'info',
+      `Cert provisioning sweep: ${tasks.length} domain(s) to provision (${skippedValid} valid skipped, ${skippedCooldown} in cooldown)`,
+      { component: 'smart-proxy' },
+    );
+
     // Phase 2: Process all domains in parallel with concurrency limit
     const concurrency = this.settings.certProvisionConcurrency ?? 4;
     const semaphore = new ConcurrencySemaphore(concurrency);
@@ -952,6 +1094,12 @@ export class SmartProxy extends plugins.EventEmitter {
           certObj.privateKey,
           certObj.ca,
         );
+        this.certFailureAt.delete(domain);
+        this.recordCertValidity(
+          domain,
+          certObj.publicKey,
+          typeof certObj.validUntil === 'number' ? certObj.validUntil : undefined,
+        );
         logger.log('info', `Certificate loaded via provision function for ${domain}`, { component: 'smart-proxy' });
 
         // Persist to consumer store
@@ -972,6 +1120,10 @@ export class SmartProxy extends plugins.EventEmitter {
     } catch (err: any) {
       logger.log('warn', `certProvisionFunction failed for ${domain}: ${err.message}`, { component: 'smart-proxy' });
 
+      // Start the per-domain failure cooldown so subsequent sweeps skip this
+      // domain instead of re-running ACME orders back to back.
+      this.certFailureAt.set(domain, Date.now());
+
       this.emit('certificate-failed', {
         domain,
         error: err.message,