@push.rocks/smartproxy 25.2.2 → 25.3.1

package/changelog.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## 2026-02-15 - 25.3.1 - fix(plugins)
+remove unused dependencies and simplify plugin exports
+
+- Removed multiple dependencies from package.json to reduce dependency footprint: @push.rocks/lik, @push.rocks/smartacme, @push.rocks/smartdelay, @push.rocks/smartfile, @push.rocks/smartnetwork, @push.rocks/smartpromise, @push.rocks/smartrequest, @push.rocks/smartrx, @push.rocks/smartstring, @push.rocks/taskbuffer, @types/minimatch, @types/ws, pretty-ms, ws
+- ts/plugins.ts: stopped importing/exporting node:https and many push.rocks and third-party modules; plugins now only re-export core node modules (without https), tsclass, smartcrypto, smartlog (+ destination-local), smartrust, and minimatch
+- Intended effect: trim surface area and remove unused/optional integrations; patch-level change (no feature/API additions)
+
+## 2026-02-14 - 25.3.0 - feat(smart-proxy)
+add background concurrent certificate provisioning with per-domain timeouts and concurrency control
+
+- Add ISmartProxyOptions settings: certProvisionTimeout (ms) and certProvisionConcurrency (default 4)
+- Run certProvisionFunction as fire-and-forget background tasks (stores promise on start/route-update and awaited on stop)
+- Provision certificates in parallel with a concurrency limit using a new ConcurrencySemaphore utility
+- Introduce per-domain timeout handling (default 300000ms) via withTimeout and surface timeout errors as certificate-failed events
+- Refactor provisioning into provisionSingleDomain to isolate domain handling, ACME fallback preserved
+- Run provisioning outside route update mutex so route updates are not blocked by slow provisioning
+
 ## 2026-02-14 - 25.2.2 - fix(smart-proxy)
 start metrics polling before certificate provisioning to avoid blocking metrics collection
 

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@push.rocks/smartproxy',
-    version: '25.2.2',
+    version: '25.3.1',
     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/core/utils/logger.d.ts

@@ -1,2 +1,2 @@
 import * as plugins from '../../plugins.js';
-export declare const logger: plugins.smartacmePlugins.smartlog.Smartlog;
+export declare const logger: plugins.smartlog.Smartlog;

package/dist_ts/plugins.d.ts

@@ -1,33 +1,18 @@
 import { EventEmitter } from 'node:events';
 import * as fs from 'node:fs';
 import * as http from 'node:http';
-import * as https from 'node:https';
 import * as net from 'node:net';
 import * as path from 'node:path';
 import * as tls from 'node:tls';
 import * as url from 'node:url';
 import * as http2 from 'node:http2';
-export { EventEmitter, fs, http, https, net, path, tls, url, http2 };
+export { EventEmitter, fs, http, net, path, tls, url, http2 };
 import * as tsclass from '@tsclass/tsclass';
 export { tsclass };
-import * as lik from '@push.rocks/lik';
-import * as smartdelay from '@push.rocks/smartdelay';
-import * as smartpromise from '@push.rocks/smartpromise';
-import * as smartrequest from '@push.rocks/smartrequest';
-import * as smartstring from '@push.rocks/smartstring';
-import * as smartfile from '@push.rocks/smartfile';
 import * as smartcrypto from '@push.rocks/smartcrypto';
-import * as smartacme from '@push.rocks/smartacme';
-import * as smartacmePlugins from '@push.rocks/smartacme/dist_ts/smartacme.plugins.js';
-import * as smartacmeHandlers from '@push.rocks/smartacme/dist_ts/handlers/index.js';
 import * as smartlog from '@push.rocks/smartlog';
 import * as smartlogDestinationLocal from '@push.rocks/smartlog/destination-local';
-import * as taskbuffer from '@push.rocks/taskbuffer';
-import * as smartrx from '@push.rocks/smartrx';
 import * as smartrust from '@push.rocks/smartrust';
-export { lik, smartdelay, smartrequest, smartpromise, smartstring, smartfile, smartcrypto, smartacme, smartacmePlugins, smartacmeHandlers, smartlog, smartlogDestinationLocal, taskbuffer, smartrx, smartrust, };
-import prettyMs from 'pretty-ms';
-import * as ws from 'ws';
-import wsDefault from 'ws';
+export { smartcrypto, smartlog, smartlogDestinationLocal, smartrust, };
 import { minimatch } from 'minimatch';
-export { prettyMs, ws, wsDefault, minimatch };
+export { minimatch };

package/dist_ts/plugins.js

@@ -2,37 +2,22 @@
 import { EventEmitter } from 'node:events';
 import * as fs from 'node:fs';
 import * as http from 'node:http';
-import * as https from 'node:https';
 import * as net from 'node:net';
 import * as path from 'node:path';
 import * as tls from 'node:tls';
 import * as url from 'node:url';
 import * as http2 from 'node:http2';
-export { EventEmitter, fs, http, https, net, path, tls, url, http2 };
+export { EventEmitter, fs, http, net, path, tls, url, http2 };
 // tsclass scope
 import * as tsclass from '@tsclass/tsclass';
 export { tsclass };
 // pushrocks scope
-import * as lik from '@push.rocks/lik';
-import * as smartdelay from '@push.rocks/smartdelay';
-import * as smartpromise from '@push.rocks/smartpromise';
-import * as smartrequest from '@push.rocks/smartrequest';
-import * as smartstring from '@push.rocks/smartstring';
-import * as smartfile from '@push.rocks/smartfile';
 import * as smartcrypto from '@push.rocks/smartcrypto';
-import * as smartacme from '@push.rocks/smartacme';
-import * as smartacmePlugins from '@push.rocks/smartacme/dist_ts/smartacme.plugins.js';
-import * as smartacmeHandlers from '@push.rocks/smartacme/dist_ts/handlers/index.js';
 import * as smartlog from '@push.rocks/smartlog';
 import * as smartlogDestinationLocal from '@push.rocks/smartlog/destination-local';
-import * as taskbuffer from '@push.rocks/taskbuffer';
-import * as smartrx from '@push.rocks/smartrx';
 import * as smartrust from '@push.rocks/smartrust';
-export { lik, smartdelay, smartrequest, smartpromise, smartstring, smartfile, smartcrypto, smartacme, smartacmePlugins, smartacmeHandlers, smartlog, smartlogDestinationLocal, taskbuffer, smartrx, smartrust, };
+export { smartcrypto, smartlog, smartlogDestinationLocal, smartrust, };
 // third party scope
-import prettyMs from 'pretty-ms';
-import * as ws from 'ws';
-import wsDefault from 'ws';
 import { minimatch } from 'minimatch';
-export { prettyMs, ws, wsDefault, minimatch };
-//# sourceMappingURL=data:application/json;base64,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
+export { minimatch };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsb0JBQW9CO0FBQ3BCLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxhQUFhLENBQUM7QUFDM0MsT0FBTyxLQUFLLEVBQUUsTUFBTSxTQUFTLENBQUM7QUFDOUIsT0FBTyxLQUFLLElBQUksTUFBTSxXQUFXLENBQUM7QUFDbEMsT0FBTyxLQUFLLEdBQUcsTUFBTSxVQUFVLENBQUM7QUFDaEMsT0FBTyxLQUFLLElBQUksTUFBTSxXQUFXLENBQUM7QUFDbEMsT0FBTyxLQUFLLEdBQUcsTUFBTSxVQUFVLENBQUM7QUFDaEMsT0FBTyxLQUFLLEdBQUcsTUFBTSxVQUFVLENBQUM7QUFDaEMsT0FBTyxLQUFLLEtBQUssTUFBTSxZQUFZLENBQUM7QUFFcEMsT0FBTyxFQUFFLFlBQVksRUFBRSxFQUFFLEVBQUUsSUFBSSxFQUFFLEdBQUcsRUFBRSxJQUFJLEVBQUUsR0FBRyxFQUFFLEdBQUcsRUFBRSxLQUFLLEVBQUUsQ0FBQztBQUU5RCxnQkFBZ0I7QUFDaEIsT0FBTyxLQUFLLE9BQU8sTUFBTSxrQkFBa0IsQ0FBQztBQUU1QyxPQUFPLEVBQUUsT0FBTyxFQUFFLENBQUM7QUFFbkIsa0JBQWtCO0FBQ2xCLE9BQU8sS0FBSyxXQUFXLE1BQU0seUJBQXlCLENBQUM7QUFDdkQsT0FBTyxLQUFLLFFBQVEsTUFBTSxzQkFBc0IsQ0FBQztBQUNqRCxPQUFPLEtBQUssd0JBQXdCLE1BQU0sd0NBQXdDLENBQUM7QUFDbkYsT0FBTyxLQUFLLFNBQVMsTUFBTSx1QkFBdUIsQ0FBQztBQUVuRCxPQUFPLEVBQ0wsV0FBVyxFQUNYLFFBQVEsRUFDUix3QkFBd0IsRUFDeEIsU0FBUyxHQUNWLENBQUM7QUFFRixvQkFBb0I7QUFDcEIsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLFdBQVcsQ0FBQztBQUV0QyxPQUFPLEVBQUUsU0FBUyxFQUFFLENBQUMifQ==

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

@@ -150,6 +150,19 @@ export interface ISmartProxyOptions {
      * Default: true
      */
     certProvisionFallbackToAcme?: boolean;
+    /**
+     * Per-domain timeout in ms for certProvisionFunction calls.
+     * If a single domain's provisioning takes longer than this, it's aborted
+     * and a certificate-failed event is emitted.
+     * Default: 300000 (5 minutes)
+     */
+    certProvisionTimeout?: number;
+    /**
+     * Maximum number of domains to provision certificates for concurrently.
+     * Prevents overwhelming ACME providers when many domains provision at once.
+     * Default: 4
+     */
+    certProvisionConcurrency?: 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

@@ -22,6 +22,7 @@ export declare class SmartProxy extends plugins.EventEmitter {
     private metricsAdapter;
     private routeUpdateLock;
     private stopping;
+    private certProvisionPromise;
     constructor(settingsArg: ISmartProxyOptions);
     /**
      * Start the proxy.
@@ -86,6 +87,15 @@ export declare class SmartProxy extends plugins.EventEmitter {
      * If it returns 'http01', let Rust handle ACME.
      */
     private provisionCertificatesViaCallback;
+    /**
+     * Provision a single domain's certificate via the callback.
+     * Includes per-domain timeout and shutdown checks.
+     */
+    private provisionSingleDomain;
+    /**
+     * Race a promise against a timeout. Rejects with the given message if the timeout fires first.
+     */
+    private withTimeout;
     /**
      * Normalize routing glob patterns into valid domain identifiers for cert provisioning.
      * - `*nevermind.cloud` → `['nevermind.cloud', '*.nevermind.cloud']`

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

@@ -10,6 +10,7 @@ import { SharedRouteManager as RouteManager } from '../../core/routing/route-man
 import { RouteValidator } from './utils/route-validator.js';
 import { generateDefaultCertificate } from './utils/default-cert-generator.js';
 import { Mutex } from './utils/mutex.js';
+import { ConcurrencySemaphore } from './utils/concurrency-semaphore.js';
 /**
  * SmartProxy - Rust-backed proxy engine with TypeScript configuration API.
  *
@@ -25,6 +26,7 @@ export class SmartProxy extends plugins.EventEmitter {
         super();
         this.socketHandlerServer = null;
         this.stopping = false;
+        this.certProvisionPromise = null;
         // Apply defaults
         this.settings = {
             ...settingsArg,
@@ -158,8 +160,10 @@ export class SmartProxy extends plugins.EventEmitter {
         // not block metrics collection.
         this.metricsAdapter.startPolling();
         logger.log('info', 'SmartProxy started (Rust engine)', { component: 'smart-proxy' });
-        // Handle certProvisionFunction (may be slow — runs after startup is complete)
-        await this.provisionCertificatesViaCallback(preloadedDomains);
+        // 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' }));
     }
     /**
      * Stop the proxy.
@@ -167,6 +171,11 @@ export class SmartProxy extends plugins.EventEmitter {
     async stop() {
         logger.log('info', 'SmartProxy shutting down...', { component: 'smart-proxy' });
         this.stopping = true;
+        // Wait for in-flight cert provisioning to bail out (it checks this.stopping)
+        if (this.certProvisionPromise) {
+            await this.certProvisionPromise;
+            this.certProvisionPromise = null;
+        }
         // Stop metrics polling
         this.metricsAdapter.stopPolling();
         // Remove exit listener before killing to avoid spurious error events
@@ -190,7 +199,7 @@ export class SmartProxy extends plugins.EventEmitter {
      * Update routes atomically.
      */
     async updateRoutes(newRoutes) {
-        return this.routeUpdateLock.runExclusive(async () => {
+        await this.routeUpdateLock.runExclusive(async () => {
             // Validate
             const validation = RouteValidator.validateRoutes(newRoutes);
             if (!validation.valid) {
@@ -217,10 +226,12 @@ export class SmartProxy extends plugins.EventEmitter {
             }
             // Update stored routes
             this.settings.routes = newRoutes;
-            // Handle cert provisioning for new routes
-            await this.provisionCertificatesViaCallback();
             logger.log('info', `Routes updated (${newRoutes.length} routes)`, { component: 'smart-proxy' });
         });
+        // 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' }));
     }
     /**
      * Provision a certificate for a named route.
@@ -341,7 +352,9 @@ export class SmartProxy extends plugins.EventEmitter {
         const provisionFn = this.settings.certProvisionFunction;
         if (!provisionFn)
             return;
-        const provisionedDomains = new Set(skipDomains);
+        // Phase 1: Collect all unique (domain, route) pairs that need provisioning
+        const seen = new Set(skipDomains);
+        const tasks = [];
         for (const route of this.settings.routes) {
             if (route.action.tls?.certificate !== 'auto')
                 continue;
@@ -350,82 +363,115 @@ export class SmartProxy extends plugins.EventEmitter {
             const rawDomains = Array.isArray(route.match.domains) ? route.match.domains : [route.match.domains];
             const certDomains = this.normalizeDomainsForCertProvisioning(rawDomains);
             for (const domain of certDomains) {
-                if (provisionedDomains.has(domain))
+                if (seen.has(domain))
                     continue;
-                provisionedDomains.add(domain);
-                // Build eventComms channel for this domain
-                let expiryDate;
-                let source = 'certProvisionFunction';
-                const eventComms = {
-                    log: (msg) => logger.log('info', `[certProvision ${domain}] ${msg}`, { component: 'smart-proxy' }),
-                    warn: (msg) => logger.log('warn', `[certProvision ${domain}] ${msg}`, { component: 'smart-proxy' }),
-                    error: (msg) => logger.log('error', `[certProvision ${domain}] ${msg}`, { component: 'smart-proxy' }),
-                    setExpiryDate: (date) => { expiryDate = date.toISOString(); },
-                    setSource: (s) => { source = s; },
-                };
-                try {
-                    const result = await provisionFn(domain, eventComms);
-                    if (result === 'http01') {
-                        // Callback wants HTTP-01 for this domain — trigger Rust ACME explicitly
-                        if (route.name) {
-                            try {
-                                await this.bridge.provisionCertificate(route.name);
-                                logger.log('info', `Triggered Rust ACME for ${domain} (route: ${route.name})`, { component: 'smart-proxy' });
-                            }
-                            catch (provisionErr) {
-                                logger.log('warn', `Cannot provision cert for ${domain} — callback returned 'http01' but Rust ACME failed: ${provisionErr.message}. ` +
-                                    'Note: Rust ACME is disabled when certProvisionFunction is set.', { component: 'smart-proxy' });
-                            }
-                        }
-                        continue;
+                seen.add(domain);
+                tasks.push({ domain, route });
+            }
+        }
+        if (tasks.length === 0)
+            return;
+        // Phase 2: Process all domains in parallel with concurrency limit
+        const concurrency = this.settings.certProvisionConcurrency ?? 4;
+        const semaphore = new ConcurrencySemaphore(concurrency);
+        const promises = tasks.map(async ({ domain, route }) => {
+            await semaphore.acquire();
+            try {
+                await this.provisionSingleDomain(domain, route, provisionFn);
+            }
+            finally {
+                semaphore.release();
+            }
+        });
+        await Promise.allSettled(promises);
+    }
+    /**
+     * Provision a single domain's certificate via the callback.
+     * Includes per-domain timeout and shutdown checks.
+     */
+    async provisionSingleDomain(domain, route, provisionFn) {
+        if (this.stopping)
+            return;
+        let expiryDate;
+        let source = 'certProvisionFunction';
+        const eventComms = {
+            log: (msg) => logger.log('info', `[certProvision ${domain}] ${msg}`, { component: 'smart-proxy' }),
+            warn: (msg) => logger.log('warn', `[certProvision ${domain}] ${msg}`, { component: 'smart-proxy' }),
+            error: (msg) => logger.log('error', `[certProvision ${domain}] ${msg}`, { component: 'smart-proxy' }),
+            setExpiryDate: (date) => { expiryDate = date.toISOString(); },
+            setSource: (s) => { source = s; },
+        };
+        const timeoutMs = this.settings.certProvisionTimeout ?? 300_000; // 5 min default
+        try {
+            const result = await this.withTimeout(provisionFn(domain, eventComms), timeoutMs, `Certificate provisioning timed out for ${domain} after ${timeoutMs}ms`);
+            if (this.stopping)
+                return;
+            if (result === 'http01') {
+                if (route.name) {
+                    try {
+                        await this.bridge.provisionCertificate(route.name);
+                        logger.log('info', `Triggered Rust ACME for ${domain} (route: ${route.name})`, { component: 'smart-proxy' });
                     }
-                    // Got a static cert object - load it into Rust
-                    if (result && typeof result === 'object') {
-                        const certObj = result;
-                        await this.bridge.loadCertificate(domain, certObj.publicKey, certObj.privateKey);
-                        logger.log('info', `Certificate loaded via provision function for ${domain}`, { component: 'smart-proxy' });
-                        // Persist to consumer store
-                        if (this.settings.certStore?.save) {
-                            try {
-                                await this.settings.certStore.save(domain, certObj.publicKey, certObj.privateKey);
-                            }
-                            catch (storeErr) {
-                                logger.log('warn', `certStore.save() failed for ${domain}: ${storeErr.message}`, { component: 'smart-proxy' });
-                            }
-                        }
-                        // Emit certificate-issued event
-                        this.emit('certificate-issued', {
-                            domain,
-                            expiryDate: expiryDate || (certObj.validUntil ? new Date(certObj.validUntil).toISOString() : undefined),
-                            source,
-                        });
+                    catch (provisionErr) {
+                        logger.log('warn', `Cannot provision cert for ${domain} — callback returned 'http01' but Rust ACME failed: ${provisionErr.message}. ` +
+                            'Note: Rust ACME is disabled when certProvisionFunction is set.', { component: 'smart-proxy' });
                     }
                 }
-                catch (err) {
-                    logger.log('warn', `certProvisionFunction failed for ${domain}: ${err.message}`, { component: 'smart-proxy' });
-                    // Emit certificate-failed event
-                    this.emit('certificate-failed', {
-                        domain,
-                        error: err.message,
-                        source,
-                    });
-                    // Fallback to ACME if enabled and route has a name
-                    if (this.settings.certProvisionFallbackToAcme !== false && route.name) {
-                        try {
-                            await this.bridge.provisionCertificate(route.name);
-                            logger.log('info', `Falling back to Rust ACME for ${domain} (route: ${route.name})`, { component: 'smart-proxy' });
-                        }
-                        catch (acmeErr) {
-                            logger.log('warn', `ACME fallback also failed for ${domain}: ${acmeErr.message}` +
-                                (this.settings.disableDefaultCert
-                                    ? ' — TLS will fail for this domain (disableDefaultCert is true)'
-                                    : ' — default self-signed fallback cert will be used'), { component: 'smart-proxy' });
-                        }
+                return;
+            }
+            if (result && typeof result === 'object') {
+                if (this.stopping)
+                    return;
+                const certObj = result;
+                await this.bridge.loadCertificate(domain, certObj.publicKey, certObj.privateKey);
+                logger.log('info', `Certificate loaded via provision function for ${domain}`, { component: 'smart-proxy' });
+                // Persist to consumer store
+                if (this.settings.certStore?.save) {
+                    try {
+                        await this.settings.certStore.save(domain, certObj.publicKey, certObj.privateKey);
                     }
+                    catch (storeErr) {
+                        logger.log('warn', `certStore.save() failed for ${domain}: ${storeErr.message}`, { component: 'smart-proxy' });
+                    }
+                }
+                this.emit('certificate-issued', {
+                    domain,
+                    expiryDate: expiryDate || (certObj.validUntil ? new Date(certObj.validUntil).toISOString() : undefined),
+                    source,
+                });
+            }
+        }
+        catch (err) {
+            logger.log('warn', `certProvisionFunction failed for ${domain}: ${err.message}`, { component: 'smart-proxy' });
+            this.emit('certificate-failed', {
+                domain,
+                error: err.message,
+                source,
+            });
+            // Fallback to ACME if enabled and route has a name
+            if (this.settings.certProvisionFallbackToAcme !== false && route.name) {
+                try {
+                    await this.bridge.provisionCertificate(route.name);
+                    logger.log('info', `Falling back to Rust ACME for ${domain} (route: ${route.name})`, { component: 'smart-proxy' });
+                }
+                catch (acmeErr) {
+                    logger.log('warn', `ACME fallback also failed for ${domain}: ${acmeErr.message}` +
+                        (this.settings.disableDefaultCert
+                            ? ' — TLS will fail for this domain (disableDefaultCert is true)'
+                            : ' — default self-signed fallback cert will be used'), { component: 'smart-proxy' });
                 }
             }
         }
     }
+    /**
+     * Race a promise against a timeout. Rejects with the given message if the timeout fires first.
+     */
+    withTimeout(promise, ms, message) {
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => reject(new Error(message)), ms);
+            promise.then((val) => { clearTimeout(timer); resolve(val); }, (err) => { clearTimeout(timer); reject(err); });
+        });
+    }
     /**
      * Normalize routing glob patterns into valid domain identifiers for cert provisioning.
      * - `*nevermind.cloud` → `['nevermind.cloud', '*.nevermind.cloud']`
@@ -468,4 +514,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/dist_ts/proxies/smart-proxy/utils/concurrency-semaphore.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Async concurrency semaphore — limits the number of concurrent async operations.
+ */
+export declare class ConcurrencySemaphore {
+    private readonly maxConcurrency;
+    private running;
+    private waitQueue;
+    constructor(maxConcurrency: number);
+    acquire(): Promise<void>;
+    release(): void;
+}

package/dist_ts/proxies/smart-proxy/utils/concurrency-semaphore.js

@@ -0,0 +1,29 @@
+/**
+ * Async concurrency semaphore — limits the number of concurrent async operations.
+ */
+export class ConcurrencySemaphore {
+    constructor(maxConcurrency) {
+        this.maxConcurrency = maxConcurrency;
+        this.running = 0;
+        this.waitQueue = [];
+    }
+    async acquire() {
+        if (this.running < this.maxConcurrency) {
+            this.running++;
+            return;
+        }
+        return new Promise((resolve) => {
+            this.waitQueue.push(() => {
+                this.running++;
+                resolve();
+            });
+        });
+    }
+    release() {
+        this.running--;
+        const next = this.waitQueue.shift();
+        if (next)
+            next();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uY3VycmVuY3ktc2VtYXBob3JlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vdHMvcHJveGllcy9zbWFydC1wcm94eS91dGlscy9jb25jdXJyZW5jeS1zZW1hcGhvcmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFDSCxNQUFNLE9BQU8sb0JBQW9CO0lBSS9CLFlBQTZCLGNBQXNCO1FBQXRCLG1CQUFjLEdBQWQsY0FBYyxDQUFRO1FBSDNDLFlBQU8sR0FBRyxDQUFDLENBQUM7UUFDWixjQUFTLEdBQXNCLEVBQUUsQ0FBQztJQUVZLENBQUM7SUFFdkQsS0FBSyxDQUFDLE9BQU87UUFDWCxJQUFJLElBQUksQ0FBQyxPQUFPLEdBQUcsSUFBSSxDQUFDLGNBQWMsRUFBRSxDQUFDO1lBQ3ZDLElBQUksQ0FBQyxPQUFPLEVBQUUsQ0FBQztZQUNmLE9BQU87UUFDVCxDQUFDO1FBQ0QsT0FBTyxJQUFJLE9BQU8sQ0FBTyxDQUFDLE9BQU8sRUFBRSxFQUFFO1lBQ25DLElBQUksQ0FBQyxTQUFTLENBQUMsSUFBSSxDQUFDLEdBQUcsRUFBRTtnQkFDdkIsSUFBSSxDQUFDLE9BQU8sRUFBRSxDQUFDO2dCQUNmLE9BQU8sRUFBRSxDQUFDO1lBQ1osQ0FBQyxDQUFDLENBQUM7UUFDTCxDQUFDLENBQUMsQ0FBQztJQUNMLENBQUM7SUFFRCxPQUFPO1FBQ0wsSUFBSSxDQUFDLE9BQU8sRUFBRSxDQUFDO1FBQ2YsTUFBTSxJQUFJLEdBQUcsSUFBSSxDQUFDLFNBQVMsQ0FBQyxLQUFLLEVBQUUsQ0FBQztRQUNwQyxJQUFJLElBQUk7WUFBRSxJQUFJLEVBQUUsQ0FBQztJQUNuQixDQUFDO0NBQ0YifQ==

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

@@ -8,4 +8,5 @@ export * from './route-helpers.js';
 export * from './route-validator.js';
 export * from './route-utils.js';
 export { generateDefaultCertificate } from './default-cert-generator.js';
+export { ConcurrencySemaphore } from './concurrency-semaphore.js';
 export { createApiGatewayRoute, addRateLimiting, addBasicAuth, addJwtAuth } from './route-helpers.js';

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

@@ -12,6 +12,8 @@ export * from './route-validator.js';
 export * from './route-utils.js';
 // Export default certificate generator
 export { generateDefaultCertificate } from './default-cert-generator.js';
+// Export concurrency semaphore
+export { ConcurrencySemaphore } from './concurrency-semaphore.js';
 // Export additional functions from route-helpers that weren't already exported
 export { createApiGatewayRoute, addRateLimiting, addBasicAuth, addJwtAuth } from './route-helpers.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi90cy9wcm94aWVzL3NtYXJ0LXByb3h5L3V0aWxzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7OztHQUtHO0FBRUgseURBQXlEO0FBQ3pELGNBQWMsb0JBQW9CLENBQUM7QUFFbkMsMERBQTBEO0FBQzFELGNBQWMsc0JBQXNCLENBQUM7QUFFckMsOENBQThDO0FBQzlDLGNBQWMsa0JBQWtCLENBQUM7QUFFakMsdUNBQXVDO0FBQ3ZDLE9BQU8sRUFBRSwwQkFBMEIsRUFBRSxNQUFNLDZCQUE2QixDQUFDO0FBRXpFLCtFQUErRTtBQUMvRSxPQUFPLEVBQ0wscUJBQXFCLEVBQ3JCLGVBQWUsRUFDZixZQUFZLEVBQ1osVUFBVSxFQUNYLE1BQU0sb0JBQW9CLENBQUMifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi90cy9wcm94aWVzL3NtYXJ0LXByb3h5L3V0aWxzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7OztHQUtHO0FBRUgseURBQXlEO0FBQ3pELGNBQWMsb0JBQW9CLENBQUM7QUFFbkMsMERBQTBEO0FBQzFELGNBQWMsc0JBQXNCLENBQUM7QUFFckMsOENBQThDO0FBQzlDLGNBQWMsa0JBQWtCLENBQUM7QUFFakMsdUNBQXVDO0FBQ3ZDLE9BQU8sRUFBRSwwQkFBMEIsRUFBRSxNQUFNLDZCQUE2QixDQUFDO0FBRXpFLCtCQUErQjtBQUMvQixPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQztBQUVsRSwrRUFBK0U7QUFDL0UsT0FBTyxFQUNMLHFCQUFxQixFQUNyQixlQUFlLEVBQ2YsWUFBWSxFQUNaLFVBQVUsRUFDWCxNQUFNLG9CQUFvQixDQUFDIn0=

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/smartproxy",
-  "version": "25.2.2",
+  "version": "25.3.1",
   "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",
@@ -25,25 +25,11 @@
     "why-is-node-running": "^3.2.2"
   },
   "dependencies": {
-    "@push.rocks/lik": "^6.2.2",
-    "@push.rocks/smartacme": "^8.0.0",
     "@push.rocks/smartcrypto": "^2.0.4",
-    "@push.rocks/smartdelay": "^3.0.5",
-    "@push.rocks/smartfile": "^13.1.2",
     "@push.rocks/smartlog": "^3.1.10",
-    "@push.rocks/smartnetwork": "^4.4.0",
-    "@push.rocks/smartpromise": "^4.2.3",
-    "@push.rocks/smartrequest": "^5.0.1",
     "@push.rocks/smartrust": "^1.2.1",
-    "@push.rocks/smartrx": "^3.0.10",
-    "@push.rocks/smartstring": "^4.1.0",
-    "@push.rocks/taskbuffer": "^4.2.0",
     "@tsclass/tsclass": "^9.3.0",
-    "@types/minimatch": "^6.0.0",
-    "@types/ws": "^8.18.1",
-    "minimatch": "^10.2.0",
-    "pretty-ms": "^9.3.0",
-    "ws": "^8.19.0"
+    "minimatch": "^10.2.0"
   },
   "files": [
     "ts/**/*",

package/ts/00_commitinfo_data.ts

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

@@ -2,14 +2,13 @@
 import { EventEmitter } from 'node:events';
 import * as fs from 'node:fs';
 import * as http from 'node:http';
-import * as https from 'node:https';
 import * as net from 'node:net';
 import * as path from 'node:path';
 import * as tls from 'node:tls';
 import * as url from 'node:url';
 import * as http2 from 'node:http2';
 
-export { EventEmitter, fs, http, https, net, path, tls, url, http2 };
+export { EventEmitter, fs, http, net, path, tls, url, http2 };
 
 // tsclass scope
 import * as tsclass from '@tsclass/tsclass';
@@ -17,44 +16,19 @@ import * as tsclass from '@tsclass/tsclass';
 export { tsclass };
 
 // pushrocks scope
-import * as lik from '@push.rocks/lik';
-import * as smartdelay from '@push.rocks/smartdelay';
-import * as smartpromise from '@push.rocks/smartpromise';
-import * as smartrequest from '@push.rocks/smartrequest';
-import * as smartstring from '@push.rocks/smartstring';
-import * as smartfile from '@push.rocks/smartfile';
 import * as smartcrypto from '@push.rocks/smartcrypto';
-import * as smartacme from '@push.rocks/smartacme';
-import * as smartacmePlugins from '@push.rocks/smartacme/dist_ts/smartacme.plugins.js';
-import * as smartacmeHandlers from '@push.rocks/smartacme/dist_ts/handlers/index.js';
 import * as smartlog from '@push.rocks/smartlog';
 import * as smartlogDestinationLocal from '@push.rocks/smartlog/destination-local';
-import * as taskbuffer from '@push.rocks/taskbuffer';
-import * as smartrx from '@push.rocks/smartrx';
 import * as smartrust from '@push.rocks/smartrust';
 
 export {
-  lik,
-  smartdelay,
-  smartrequest,
-  smartpromise,
-  smartstring,
-  smartfile,
   smartcrypto,
-  smartacme,
-  smartacmePlugins,
-  smartacmeHandlers,
   smartlog,
   smartlogDestinationLocal,
-  taskbuffer,
-  smartrx,
   smartrust,
 };
 
 // third party scope
-import prettyMs from 'pretty-ms';
-import * as ws from 'ws';
-import wsDefault from 'ws';
 import { minimatch } from 'minimatch';
 
-export { prettyMs, ws, wsDefault, minimatch };
+export { minimatch };

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

@@ -180,6 +180,21 @@ export interface ISmartProxyOptions {
    */
   certProvisionFallbackToAcme?: boolean;
 
+  /**
+   * Per-domain timeout in ms for certProvisionFunction calls.
+   * If a single domain's provisioning takes longer than this, it's aborted
+   * and a certificate-failed event is emitted.
+   * Default: 300000 (5 minutes)
+   */
+  certProvisionTimeout?: number;
+
+  /**
+   * Maximum number of domains to provision certificates for concurrently.
+   * Prevents overwhelming ACME providers when many domains provision at once.
+   * Default: 4
+   */
+  certProvisionConcurrency?: 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

@@ -12,6 +12,7 @@ import { SharedRouteManager as RouteManager } from '../../core/routing/route-man
 import { RouteValidator } from './utils/route-validator.js';
 import { generateDefaultCertificate } from './utils/default-cert-generator.js';
 import { Mutex } from './utils/mutex.js';
+import { ConcurrencySemaphore } from './utils/concurrency-semaphore.js';
 
 // Types
 import type { ISmartProxyOptions, TSmartProxyCertProvisionObject, IAcmeOptions, ICertProvisionEventComms, ICertificateIssuedEvent, ICertificateFailedEvent } from './models/interfaces.js';
@@ -38,6 +39,7 @@ export class SmartProxy extends plugins.EventEmitter {
   private metricsAdapter: RustMetricsAdapter;
   private routeUpdateLock: Mutex;
   private stopping = false;
+  private certProvisionPromise: Promise<void> | null = null;
 
   constructor(settingsArg: ISmartProxyOptions) {
     super();
@@ -199,8 +201,10 @@ export class SmartProxy extends plugins.EventEmitter {
 
     logger.log('info', 'SmartProxy started (Rust engine)', { component: 'smart-proxy' });
 
-    // Handle certProvisionFunction (may be slow — runs after startup is complete)
-    await this.provisionCertificatesViaCallback(preloadedDomains);
+    // 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' }));
   }
 
   /**
@@ -210,6 +214,12 @@ export class SmartProxy extends plugins.EventEmitter {
     logger.log('info', 'SmartProxy shutting down...', { component: 'smart-proxy' });
     this.stopping = true;
 
+    // Wait for in-flight cert provisioning to bail out (it checks this.stopping)
+    if (this.certProvisionPromise) {
+      await this.certProvisionPromise;
+      this.certProvisionPromise = null;
+    }
+
     // Stop metrics polling
     this.metricsAdapter.stopPolling();
 
@@ -237,7 +247,7 @@ export class SmartProxy extends plugins.EventEmitter {
    * Update routes atomically.
    */
   public async updateRoutes(newRoutes: IRouteConfig[]): Promise<void> {
-    return this.routeUpdateLock.runExclusive(async () => {
+    await this.routeUpdateLock.runExclusive(async () => {
       // Validate
       const validation = RouteValidator.validateRoutes(newRoutes);
       if (!validation.valid) {
@@ -273,11 +283,13 @@ export class SmartProxy extends plugins.EventEmitter {
       // Update stored routes
       this.settings.routes = newRoutes;
 
-      // Handle cert provisioning for new routes
-      await this.provisionCertificatesViaCallback();
-
       logger.log('info', `Routes updated (${newRoutes.length} routes)`, { component: 'smart-proxy' });
     });
+
+    // 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' }));
   }
 
   /**
@@ -412,7 +424,9 @@ export class SmartProxy extends plugins.EventEmitter {
     const provisionFn = this.settings.certProvisionFunction;
     if (!provisionFn) return;
 
-    const provisionedDomains = new Set<string>(skipDomains);
+    // Phase 1: Collect all unique (domain, route) pairs that need provisioning
+    const seen = new Set<string>(skipDomains);
+    const tasks: Array<{ domain: string; route: IRouteConfig }> = [];
 
     for (const route of this.settings.routes) {
       if (route.action.tls?.certificate !== 'auto') continue;
@@ -422,91 +436,139 @@ export class SmartProxy extends plugins.EventEmitter {
       const certDomains = this.normalizeDomainsForCertProvisioning(rawDomains);
 
       for (const domain of certDomains) {
-        if (provisionedDomains.has(domain)) continue;
-        provisionedDomains.add(domain);
+        if (seen.has(domain)) continue;
+        seen.add(domain);
+        tasks.push({ domain, route });
+      }
+    }
 
-        // Build eventComms channel for this domain
-        let expiryDate: string | undefined;
-        let source = 'certProvisionFunction';
+    if (tasks.length === 0) return;
 
-        const eventComms: ICertProvisionEventComms = {
-          log: (msg) => logger.log('info', `[certProvision ${domain}] ${msg}`, { component: 'smart-proxy' }),
-          warn: (msg) => logger.log('warn', `[certProvision ${domain}] ${msg}`, { component: 'smart-proxy' }),
-          error: (msg) => logger.log('error', `[certProvision ${domain}] ${msg}`, { component: 'smart-proxy' }),
-          setExpiryDate: (date) => { expiryDate = date.toISOString(); },
-          setSource: (s) => { source = s; },
-        };
+    // Phase 2: Process all domains in parallel with concurrency limit
+    const concurrency = this.settings.certProvisionConcurrency ?? 4;
+    const semaphore = new ConcurrencySemaphore(concurrency);
 
-        try {
-          const result: TSmartProxyCertProvisionObject = await provisionFn(domain, eventComms);
-
-          if (result === 'http01') {
-            // Callback wants HTTP-01 for this domain — trigger Rust ACME explicitly
-            if (route.name) {
-              try {
-                await this.bridge.provisionCertificate(route.name);
-                logger.log('info', `Triggered Rust ACME for ${domain} (route: ${route.name})`, { component: 'smart-proxy' });
-              } catch (provisionErr: any) {
-                logger.log('warn', `Cannot provision cert for ${domain} — callback returned 'http01' but Rust ACME failed: ${provisionErr.message}. ` +
-                  'Note: Rust ACME is disabled when certProvisionFunction is set.', { component: 'smart-proxy' });
-              }
-            }
-            continue;
-          }
+    const promises = tasks.map(async ({ domain, route }) => {
+      await semaphore.acquire();
+      try {
+        await this.provisionSingleDomain(domain, route, provisionFn);
+      } finally {
+        semaphore.release();
+      }
+    });
+
+    await Promise.allSettled(promises);
+  }
+
+  /**
+   * Provision a single domain's certificate via the callback.
+   * Includes per-domain timeout and shutdown checks.
+   */
+  private async provisionSingleDomain(
+    domain: string,
+    route: IRouteConfig,
+    provisionFn: (domain: string, eventComms: ICertProvisionEventComms) => Promise<TSmartProxyCertProvisionObject>,
+  ): Promise<void> {
+    if (this.stopping) return;
+
+    let expiryDate: string | undefined;
+    let source = 'certProvisionFunction';
+
+    const eventComms: ICertProvisionEventComms = {
+      log: (msg) => logger.log('info', `[certProvision ${domain}] ${msg}`, { component: 'smart-proxy' }),
+      warn: (msg) => logger.log('warn', `[certProvision ${domain}] ${msg}`, { component: 'smart-proxy' }),
+      error: (msg) => logger.log('error', `[certProvision ${domain}] ${msg}`, { component: 'smart-proxy' }),
+      setExpiryDate: (date) => { expiryDate = date.toISOString(); },
+      setSource: (s) => { source = s; },
+    };
+
+    const timeoutMs = this.settings.certProvisionTimeout ?? 300_000; // 5 min default
+
+    try {
+      const result: TSmartProxyCertProvisionObject = await this.withTimeout(
+        provisionFn(domain, eventComms),
+        timeoutMs,
+        `Certificate provisioning timed out for ${domain} after ${timeoutMs}ms`,
+      );
 
-          // Got a static cert object - load it into Rust
-          if (result && typeof result === 'object') {
-            const certObj = result as plugins.tsclass.network.ICert;
-            await this.bridge.loadCertificate(
-              domain,
-              certObj.publicKey,
-              certObj.privateKey,
-            );
-            logger.log('info', `Certificate loaded via provision function for ${domain}`, { component: 'smart-proxy' });
-
-            // Persist to consumer store
-            if (this.settings.certStore?.save) {
-              try {
-                await this.settings.certStore.save(domain, certObj.publicKey, certObj.privateKey);
-              } catch (storeErr: any) {
-                logger.log('warn', `certStore.save() failed for ${domain}: ${storeErr.message}`, { component: 'smart-proxy' });
-              }
-            }
-
-            // Emit certificate-issued event
-            this.emit('certificate-issued', {
-              domain,
-              expiryDate: expiryDate || (certObj.validUntil ? new Date(certObj.validUntil).toISOString() : undefined),
-              source,
-            } satisfies ICertificateIssuedEvent);
+      if (this.stopping) return;
+
+      if (result === 'http01') {
+        if (route.name) {
+          try {
+            await this.bridge.provisionCertificate(route.name);
+            logger.log('info', `Triggered Rust ACME for ${domain} (route: ${route.name})`, { component: 'smart-proxy' });
+          } catch (provisionErr: any) {
+            logger.log('warn', `Cannot provision cert for ${domain} — callback returned 'http01' but Rust ACME failed: ${provisionErr.message}. ` +
+              'Note: Rust ACME is disabled when certProvisionFunction is set.', { component: 'smart-proxy' });
           }
-        } catch (err: any) {
-          logger.log('warn', `certProvisionFunction failed for ${domain}: ${err.message}`, { component: 'smart-proxy' });
-
-          // Emit certificate-failed event
-          this.emit('certificate-failed', {
-            domain,
-            error: err.message,
-            source,
-          } satisfies ICertificateFailedEvent);
-
-          // Fallback to ACME if enabled and route has a name
-          if (this.settings.certProvisionFallbackToAcme !== false && route.name) {
-            try {
-              await this.bridge.provisionCertificate(route.name);
-              logger.log('info', `Falling back to Rust ACME for ${domain} (route: ${route.name})`, { component: 'smart-proxy' });
-            } catch (acmeErr: any) {
-              logger.log('warn', `ACME fallback also failed for ${domain}: ${acmeErr.message}` +
-                (this.settings.disableDefaultCert
-                  ? ' — TLS will fail for this domain (disableDefaultCert is true)'
-                  : ' — default self-signed fallback cert will be used'), { component: 'smart-proxy' });
-            }
+        }
+        return;
+      }
+
+      if (result && typeof result === 'object') {
+        if (this.stopping) return;
+
+        const certObj = result as plugins.tsclass.network.ICert;
+        await this.bridge.loadCertificate(
+          domain,
+          certObj.publicKey,
+          certObj.privateKey,
+        );
+        logger.log('info', `Certificate loaded via provision function for ${domain}`, { component: 'smart-proxy' });
+
+        // Persist to consumer store
+        if (this.settings.certStore?.save) {
+          try {
+            await this.settings.certStore.save(domain, certObj.publicKey, certObj.privateKey);
+          } catch (storeErr: any) {
+            logger.log('warn', `certStore.save() failed for ${domain}: ${storeErr.message}`, { component: 'smart-proxy' });
           }
         }
+
+        this.emit('certificate-issued', {
+          domain,
+          expiryDate: expiryDate || (certObj.validUntil ? new Date(certObj.validUntil).toISOString() : undefined),
+          source,
+        } satisfies ICertificateIssuedEvent);
+      }
+    } catch (err: any) {
+      logger.log('warn', `certProvisionFunction failed for ${domain}: ${err.message}`, { component: 'smart-proxy' });
+
+      this.emit('certificate-failed', {
+        domain,
+        error: err.message,
+        source,
+      } satisfies ICertificateFailedEvent);
+
+      // Fallback to ACME if enabled and route has a name
+      if (this.settings.certProvisionFallbackToAcme !== false && route.name) {
+        try {
+          await this.bridge.provisionCertificate(route.name);
+          logger.log('info', `Falling back to Rust ACME for ${domain} (route: ${route.name})`, { component: 'smart-proxy' });
+        } catch (acmeErr: any) {
+          logger.log('warn', `ACME fallback also failed for ${domain}: ${acmeErr.message}` +
+            (this.settings.disableDefaultCert
+              ? ' — TLS will fail for this domain (disableDefaultCert is true)'
+              : ' — default self-signed fallback cert will be used'), { component: 'smart-proxy' });
+        }
       }
     }
   }
 
+  /**
+   * Race a promise against a timeout. Rejects with the given message if the timeout fires first.
+   */
+  private withTimeout<T>(promise: Promise<T>, ms: number, message: string): Promise<T> {
+    return new Promise<T>((resolve, reject) => {
+      const timer = setTimeout(() => reject(new Error(message)), ms);
+      promise.then(
+        (val) => { clearTimeout(timer); resolve(val); },
+        (err) => { clearTimeout(timer); reject(err); },
+      );
+    });
+  }
+
   /**
    * Normalize routing glob patterns into valid domain identifiers for cert provisioning.
    * - `*nevermind.cloud` → `['nevermind.cloud', '*.nevermind.cloud']`

package/ts/proxies/smart-proxy/utils/concurrency-semaphore.ts

@@ -0,0 +1,28 @@
+/**
+ * Async concurrency semaphore — limits the number of concurrent async operations.
+ */
+export class ConcurrencySemaphore {
+  private running = 0;
+  private waitQueue: Array<() => void> = [];
+
+  constructor(private readonly maxConcurrency: number) {}
+
+  async acquire(): Promise<void> {
+    if (this.running < this.maxConcurrency) {
+      this.running++;
+      return;
+    }
+    return new Promise<void>((resolve) => {
+      this.waitQueue.push(() => {
+        this.running++;
+        resolve();
+      });
+    });
+  }
+
+  release(): void {
+    this.running--;
+    const next = this.waitQueue.shift();
+    if (next) next();
+  }
+}

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

@@ -17,6 +17,9 @@ export * from './route-utils.js';
 // Export default certificate generator
 export { generateDefaultCertificate } from './default-cert-generator.js';
 
+// Export concurrency semaphore
+export { ConcurrencySemaphore } from './concurrency-semaphore.js';
+
 // Export additional functions from route-helpers that weren't already exported
 export {
   createApiGatewayRoute,