@push.rocks/smartproxy 27.20.0 → 27.22.0

package/changelog.md

@@ -1,5 +1,50 @@
 # Changelog
 
+## 2026-09-24 - 27.22.0
+
+### Features
+
+- add a `'defer'` result to `certProvisionFunction` (certificates)
+  - A callback whose own certificate provider is not ready yet, for example while it is still starting, could until now only throw. SmartProxy counts a throw as a failure: it emits `certificate-failed` and holds the domain in the failure cooldown (30 minutes by default), so the sweep the consumer starts once its provider is ready skips exactly the domains that were waiting for it.
+  - A deferred domain records no failure, starts no cooldown, emits no event and takes no ACME fallback; the next sweep calls the callback for it again.
+  - Each sweep that calls the callback ends with one log line counting its outcomes, deferrals included.
+- add `invalidateCertProvisionCooldown(domain)` to lift one domain's provisioning failure cooldown (certificates)
+  - A consumer that resolves a failure outside SmartProxy, for example by issuing the domain's certificate out of band, had no supported way to make SmartProxy retry before the cooldown ran out, so the domain stayed on whatever certificate it had until then.
+  - After the call, the next `updateRoutes()` sweep retries the domain at once. The method returns whether the domain was cooling down.
+
+### Maintenance
+
+- keep the development notes out of the package (repository)
+  - `readme.hints.md` and `readme.plan.md` move into the untracked `.nogit/` folder. npm packs every root `readme.*` file whatever `files` says, so both were published with the package.
+  - `readme.metrics.md`, the design notes of the Rust metrics, is renamed to `metrics.md` and stays in the repository. npm packed it for the same reason; it is not in `files`, so it no longer ships.
+- move the development tooling to pnpm 12.4.2, `@git.zone/tstest` 6 and `@git.zone/tsrun` 3 (tooling)
+  - Pin `packageManager` to `pnpm@12.4.2` (was 11.25.0) and raise `@git.zone/tstest` from `^4.0.0` to `^6.2.0`, `@git.zone/tsrun` from `^2.0.6` to `^3.0.0`, `@git.zone/tsbuild` to `^4.5.2`, `@git.zone/tsrust` to `^1.13.2` and `@types/node` to `^26.6.1`. The existing `allowBuilds` approvals for esbuild, puppeteer and sharp cover every dependency build script in the new tree, and the runtime dependencies resolve unchanged.
+  - tstest 5 and 6 fail a test file on a nonzero exit, a signal, a timeout or an incomplete plan, not only on failed assertions; the suite needed no changes for it. No test used the renamed `TapNodeTools` storage helper, and nothing in the repository reads tsrun 2's stripped `process.argv`.
+  - tstest 6 runs the Deno leg against the pnpm-installed `node_modules` instead of a separate `deno install`; Deno rewrote the workspace dependency list in `deno.lock` to the new ranges.
+  - The three `test/core/routing` tests now end with `export default tap.start()` like every other test file.
+- raise `@git.zone/tsbuild` from `^4.5.2` to `^5.0.0` (tooling)
+  - tsbuild 5 takes a source folder's own compiler options from a `tsconfig.json` in that folder and rejects the `compilerOptions` key that 4.6.0 read from `tspublish.json`. `ts/` is the only source folder here and carries neither file, so no configuration moves. The Deno test leg rewrote the tsbuild range in the workspace dependency list of `deno.lock`.
+  - `@git.zone/tsrun` `^3.0.0`, `@git.zone/tsrust` `^1.13.2` and `@git.zone/tstest` `^6.2.0` are already the current releases. `packageManager` stays `pnpm@12.4.2` and `@types/node` stays `^26.6.1`, because pnpm 12.5.0 and later and `@types/node` 26.6.2 were published less than seven days ago. The runtime dependencies resolve unchanged.
+
+## 2026-09-05 - 27.21.0
+
+### Features
+
+- add bounded HTTP domain metrics overflow reporting (proxy-runtime)
+  - Limit individually tracked HTTP domain metrics to a bounded key budget and expose overflow request rates separately.
+  - Coalesce slow metrics polls, clear stopped caches, and await native bridge termination during shutdown.
+  - Precompile and borrow HTTP header matchers to reduce request-path allocations.
+  - Optimize active connection pagination to avoid cloning and sorting the full registry.
+
+### Fixes
+
+- update development tooling dependencies and pnpm build approvals (build)
+  - Bump GitZone development tooling, test runner, and Node.js type definitions.
+  - Update the configured package manager to pnpm 11.25.0.
+  - Move package build approvals into pnpm-workspace.yaml and allow builds for esbuild, puppeteer, and sharp.
+- remove tag-triggered npm publish job from default workflow (ci)
+  - Removes the release job that published packages when tags are pushed.
+
 ## 2026-07-24 - 27.20.0
 
 ### Features

package/dist_rust/rustproxy_linux_amd64.tsrust-build.json

@@ -0,0 +1,14 @@
+{
+  "format": "tsrust.build-provenance.v2",
+  "binarySha256": "871c23a5d1c35688b1a36fc106ec385889d4d7d3cefaae0e96e9f46838af1f0c",
+  "buildInfo": {
+    "projectName": "@push.rocks/smartproxy",
+    "projectVersion": "27.22.0",
+    "gitCommit": "d3ec0ed757055b8c34faa3832c37e0d5eb041f79",
+    "gitDirty": false,
+    "builtAt": "2026-09-24T10:06:07.234Z",
+    "tsrustVersion": "1.13.2",
+    "binary": "rustproxy",
+    "target": "linux_amd64"
+  }
+}

package/dist_rust/rustproxy_linux_arm64.tsrust-build.json

@@ -0,0 +1,14 @@
+{
+  "format": "tsrust.build-provenance.v2",
+  "binarySha256": "1cb97ab1d316f25928125fc94d7a750da7b74d57821c9dee89311f472959b739",
+  "buildInfo": {
+    "projectName": "@push.rocks/smartproxy",
+    "projectVersion": "27.22.0",
+    "gitCommit": "d3ec0ed757055b8c34faa3832c37e0d5eb041f79",
+    "gitDirty": false,
+    "builtAt": "2026-09-24T10:07:08.117Z",
+    "tsrustVersion": "1.13.2",
+    "binary": "rustproxy",
+    "target": "linux_arm64"
+  }
+}

package/dist_ts/00_commitinfo_data.js

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

@@ -51,7 +51,16 @@ export interface ISmartProxyChallengeOptions {
 export interface ISmartProxyCertProvisionCertificate extends plugins.tsclass.network.ICert {
     ca?: string;
 }
-export type TSmartProxyCertProvisionObject = ISmartProxyCertProvisionCertificate | 'http01';
+/**
+ * Result of a `certProvisionFunction` call:
+ * - a certificate object: SmartProxy loads it into the Rust engine and hands it to `certStore.save()`;
+ * - `'http01'`: SmartProxy triggers Rust ACME HTTP-01 for the route;
+ * - `'defer'`: the domain cannot be provisioned yet, for example because the callback's own
+ *   certificate provider is still starting. SmartProxy records no failure, starts no cooldown
+ *   and emits no event, so the next sweep (`updateRoutes()` or the renewal check) calls the
+ *   callback for the domain again.
+ */
+export type TSmartProxyCertProvisionObject = ISmartProxyCertProvisionCertificate | 'http01' | 'defer';
 /**
  * Communication channel passed as second argument to certProvisionFunction.
  * Allows the callback to report metadata back to SmartProxy for event emission.
@@ -193,8 +202,9 @@ export interface ISmartProxyOptions {
      */
     acme?: IAcmeOptions;
     /**
-     * Optional certificate provider callback. Return 'http01' to use HTTP-01 challenges,
-     * or a static certificate object for immediate provisioning.
+     * Optional certificate provider callback. Return a static certificate object for
+     * immediate provisioning, 'http01' to use HTTP-01 challenges, or 'defer' when the
+     * domain cannot be provisioned yet (see TSmartProxyCertProvisionObject).
      */
     certProvisionFunction?: (domain: string, eventComms: ICertProvisionEventComms) => Promise<TSmartProxyCertProvisionObject>;
     /**
@@ -219,6 +229,8 @@ export interface ISmartProxyOptions {
      * 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.
+     * A 'defer' result does not start it; `invalidateCertProvisionCooldown()`
+     * lifts it once the cause is resolved elsewhere.
      * Default: 1800000 (30 minutes)
      */
     certProvisionFailureCooldownMs?: number;

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

@@ -96,6 +96,8 @@ export interface IMetrics {
         perMinute(): number;
         total(): number;
         byDomain(): Map<string, IRequestRateMetrics>;
+        /** Requests beyond the 4096-domain/253-byte key budget, without individual attribution. */
+        domainOverflow?(): IRequestRateMetrics;
     };
     totals: {
         bytesIn(): number;

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

@@ -148,6 +148,7 @@ export interface IRustMetricsSnapshot {
     httpRequestsPerSec: number;
     httpRequestsPerSecRecent: number;
     httpDomainRequests: Record<string, IRustHttpDomainRequestMetrics>;
+    httpDomainRequestsOverflow?: IRustHttpDomainRequestMetrics;
     activeUdpSessions: number;
     totalUdpSessions: number;
     totalDatagramsIn: number;

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

@@ -17,6 +17,9 @@ export declare class RustMetricsAdapter implements IMetrics {
     private historyCache;
     private pollTimer;
     private pollIntervalMs;
+    private pollPromise;
+    private generation;
+    private stopped;
     constructor(bridge: RustProxyBridge, pollIntervalMs?: number);
     /**
      * Poll Rust for metrics once. Can be awaited to ensure cache is fresh.
@@ -27,7 +30,7 @@ export declare class RustMetricsAdapter implements IMetrics {
      */
     refreshHistory(seconds: number): Promise<IMetricsHistory>;
     startPolling(): void;
-    stopPolling(): void;
+    stopPolling(): Promise<void>;
     connections: {
         active: () => number;
         total: () => number;
@@ -61,6 +64,7 @@ export declare class RustMetricsAdapter implements IMetrics {
         perSecond: () => number;
         perMinute: () => number;
         total: () => number;
+        domainOverflow: () => IRequestRateMetrics;
         byDomain: () => Map<string, IRequestRateMetrics>;
     };
     totals: {

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

@@ -57,6 +57,9 @@ export class RustMetricsAdapter {
     historyCache = null;
     pollTimer = null;
     pollIntervalMs;
+    pollPromise = null;
+    generation = 0;
+    stopped = false;
     constructor(bridge, pollIntervalMs = 1000) {
         this.bridge = bridge;
         this.pollIntervalMs = pollIntervalMs;
@@ -64,20 +67,34 @@ export class RustMetricsAdapter {
     /**
      * Poll Rust for metrics once. Can be awaited to ensure cache is fresh.
      */
-    async poll() {
-        try {
-            this.cache = await this.bridge.getMetrics();
-        }
-        catch {
-            // Ignore poll errors (bridge may be shutting down)
-        }
+    poll() {
+        if (this.stopped)
+            return Promise.resolve();
+        if (this.pollPromise)
+            return this.pollPromise;
+        const generation = this.generation;
+        this.pollPromise = (async () => {
+            try {
+                const metrics = await this.bridge.getMetrics();
+                if (!this.stopped && generation === this.generation)
+                    this.cache = metrics;
+            }
+            catch {
+                // A failed poll leaves the last successful snapshot available until stop.
+            }
+        })().finally(() => { this.pollPromise = null; });
+        return this.pollPromise;
     }
     /**
      * Fetch histories only when an observer needs them; regular polling stays lightweight.
      */
     async refreshHistory(seconds) {
+        if (this.stopped)
+            throw new Error('Metrics adapter is stopped');
+        const generation = this.generation;
         const history = await this.bridge.getMetricsHistory(seconds);
-        this.historyCache = history;
+        if (!this.stopped && generation === this.generation)
+            this.historyCache = history;
         return {
             throughputHistory: history.throughputHistory.map((point) => ({
                 timestamp: point.timestampMs,
@@ -91,6 +108,7 @@ export class RustMetricsAdapter {
     startPolling() {
         if (this.pollTimer)
             return;
+        this.stopped = false;
         // Immediate first poll so cache is populated ASAP
         this.poll();
         this.pollTimer = setInterval(() => {
@@ -100,11 +118,16 @@ export class RustMetricsAdapter {
             this.pollTimer.unref();
         }
     }
-    stopPolling() {
+    async stopPolling() {
+        this.stopped = true;
+        this.generation++;
         if (this.pollTimer) {
             clearInterval(this.pollTimer);
             this.pollTimer = null;
         }
+        this.cache = null;
+        this.historyCache = null;
+        await this.pollPromise;
     }
     // --- IMetrics implementation ---
     connections = {
@@ -276,6 +299,10 @@ export class RustMetricsAdapter {
         total: () => {
             return this.cache?.totalHttpRequests ?? this.cache?.totalConnections ?? 0;
         },
+        domainOverflow: () => ({
+            perSecond: this.cache?.httpDomainRequestsOverflow?.requestsPerSecond ?? 0,
+            lastMinute: this.cache?.httpDomainRequestsOverflow?.requestsLastMinute ?? 0,
+        }),
         byDomain: () => {
             const result = new Map();
             if (this.cache?.httpDomainRequests) {
@@ -368,4 +395,4 @@ export class RustMetricsAdapter {
         },
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rust-metrics-adapter.js","sourceRoot":"","sources":["../../../ts/proxies/smart-proxy/rust-metrics-adapter.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rust-metrics-adapter.js","sourceRoot":"","sources":["../../../ts/proxies/smart-proxy/rust-metrics-adapter.ts"],"names":[],"mappings":"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"}

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

@@ -17,6 +17,8 @@ export declare class RustProxyBridge extends plugins.EventEmitter {
      * Kill the Rust process and clean up.
      */
     kill(): void;
+    /** Resolve only when the owned native child and its stdio handles have closed. */
+    terminate(): Promise<void>;
     /**
      * Whether the bridge is currently running.
      */

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

@@ -91,6 +91,10 @@ export class RustProxyBridge extends plugins.EventEmitter {
     kill() {
         this.bridge.kill();
     }
+    /** Resolve only when the owned native child and its stdio handles have closed. */
+    async terminate() {
+        await this.bridge.terminate();
+    }
     /**
      * Whether the bridge is currently running.
      */
@@ -163,4 +167,4 @@ export class RustProxyBridge extends plugins.EventEmitter {
         await this.bridge.sendCommand('setDatagramHandlerRelay', { socketPath });
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnVzdC1wcm94eS1icmlkZ2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9wcm94aWVzL3NtYXJ0LXByb3h5L3J1c3QtcHJveHktYnJpZGdlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0sa0JBQWtCLENBQUM7QUFDNUMsT0FBTyxFQUFFLE1BQU0sRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBWXBELE1BQU0sMEJBQTBCLEdBQUcscUJBQTJCLENBQUM7QUFDL0QsTUFBTSwrQkFBK0IsR0FBRyxHQUFHLENBQUM7QUFFNUMsU0FBUyx1Q0FBdUMsQ0FBQyxPQUF5QztJQUN4RixJQUFJLE9BQU8sQ0FBQyxPQUFPLEtBQUssU0FBUyxFQUFFLENBQUM7UUFDbEMsT0FBTztJQUNULENBQUM7SUFDRCxJQUFJLE9BQU8sT0FBTyxDQUFDLE9BQU8sS0FBSyxRQUFRLElBQUksQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxPQUFPLENBQUMsRUFBRSxDQUFDO1FBQzFFLE1BQU0sSUFBSSxLQUFLLENBQUMsdUVBQXVFLENBQUMsQ0FBQztJQUMzRixDQUFDO0lBQ0QsSUFBSSxNQUFNLENBQUMsT0FBTyxDQUFDLE9BQU8sQ0FBQyxHQUFHLDBCQUEwQixFQUFFLENBQUM7UUFDekQsTUFBTSxJQUFJLEtBQUssQ0FBQywrREFBK0QsQ0FBQyxDQUFDO0lBQ25GLENBQUM7QUFDSCxDQUFDO0FBMkJEOzs7R0FHRztBQUNILFNBQVMsY0FBYztJQUNyQixNQUFNLE9BQU8sR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLGFBQWEsQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUM7SUFDakYsT0FBTyxPQUFPLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxPQUFPLEVBQUUsSUFBSSxFQUFFLElBQUksRUFBRSxJQUFJLENBQUMsQ0FBQztBQUN6RCxDQUFDO0FBRUQ7OztHQUdHO0FBQ0gsU0FBUyx1QkFBdUI7SUFDOUIsTUFBTSxPQUFPLEdBQTJCLEVBQUUsR0FBRyxFQUFFLE9BQU8sRUFBRSxLQUFLLEVBQUUsT0FBTyxFQUFFLENBQUM7SUFDekUsTUFBTSxLQUFLLEdBQTJCLEVBQUUsS0FBSyxFQUFFLE9BQU8sRUFBRSxNQUFNLEVBQUUsT0FBTyxFQUFFLENBQUM7SUFDMUUsTUFBTSxFQUFFLEdBQUcsS0FBSyxDQUFDLE9BQU8sQ0FBQyxRQUFRLENBQUMsQ0FBQztJQUNuQyxNQUFNLElBQUksR0FBRyxPQUFPLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQ25DLElBQUksRUFBRSxJQUFJLElBQUksRUFBRSxDQUFDO1FBQ2YsT0FBTyxHQUFHLEVBQUUsSUFBSSxJQUFJLEVBQUUsQ0FBQztJQUN6QixDQUFDO0lBQ0QsT0FBTyxJQUFJLENBQUM7QUFDZCxDQUFDO0FBRUQ7OztHQUdHO0FBQ0gsU0FBUyxlQUFlO0lBQ3RCLE1BQU0sV0FBVyxHQUFHLGNBQWMsRUFBRSxDQUFDO0lBQ3JDLE1BQU0sTUFBTSxHQUFHLHVCQUF1QixFQUFFLENBQUM7SUFDekMsTUFBTSxLQUFLLEdBQWEsRUFBRSxDQUFDO0lBRTNCLHVEQUF1RDtJQUN2RCxJQUFJLE1BQU0sRUFBRSxDQUFDO1FBQ1gsS0FBSyxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxXQUFXLEVBQUUsV0FBVyxFQUFFLGFBQWEsTUFBTSxFQUFFLENBQUMsQ0FBQyxDQUFDO0lBQ2pGLENBQUM7SUFDRCxLQUFLLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLFdBQVcsRUFBRSxXQUFXLEVBQUUsV0FBVyxDQUFDLENBQUMsQ0FBQztJQUVyRSx3QkFBd0I7SUFDeEIsS0FBSyxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxPQUFPLENBQUMsR0FBRyxFQUFFLEVBQUUsTUFBTSxFQUFFLFFBQVEsRUFBRSxTQUFTLEVBQUUsV0FBVyxDQUFDLENBQUMsQ0FBQztJQUMxRixLQUFLLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLE9BQU8sQ0FBQyxHQUFHLEVBQUUsRUFBRSxNQUFNLEVBQUUsUUFBUSxFQUFFLE9BQU8sRUFBRSxXQUFXLENBQUMsQ0FBQyxDQUFDO0lBRXhGLE9BQU8sS0FBSyxDQUFDO0FBQ2YsQ0FBQztBQUVEOzs7R0FHRztBQUNILE1BQU0sT0FBTyxlQUFnQixTQUFRLE9BQU8sQ0FBQyxZQUFZO0lBQy9DLE1BQU0sQ0FBb0Q7SUFFbEU7UUFDRSxLQUFLLEVBQUUsQ0FBQztRQUVSLElBQUksQ0FBQyxNQUFNLEdBQUcsSUFBSSxPQUFPLENBQUMsU0FBUyxDQUFDLFVBQVUsQ0FBc0I7WUFDbEUsVUFBVSxFQUFFLFdBQVc7WUFDdkIsVUFBVSxFQUFFLHdCQUF3QjtZQUNwQyxxQkFBcUIsRUFBRSx3QkFBd0I7WUFDL0MsVUFBVSxFQUFFLGVBQWUsRUFBRTtZQUM3QixjQUFjLEVBQUUsR0FBRyxHQUFHLElBQUksR0FBRyxJQUFJLEVBQUUsd0RBQXdEO1lBQzNGLE1BQU0sRUFBRTtnQkFDTixHQUFHLEVBQUUsQ0FBQyxLQUFhLEVBQUUsT0FBZSxFQUFFLElBQTBCLEVBQUUsRUFBRTtvQkFDbEUsTUFBTSxDQUFDLEdBQUcsQ0FBQyxLQUFZLEVBQUUsT0FBTyxFQUFFLElBQUksQ0FBQyxDQUFDO2dCQUMxQyxDQUFDO2FBQ0Y7U0FDRixDQUFDLENBQUM7UUFFSCx1Q0FBdUM7UUFDdkMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxFQUFFLENBQUMsTUFBTSxFQUFFLENBQUMsSUFBbUIsRUFBRSxNQUFxQixFQUFFLEVBQUU7WUFDcEUsSUFBSSxDQUFDLElBQUksQ0FBQyxNQUFNLEVBQUUsSUFBSSxFQUFFLE1BQU0sQ0FBQyxDQUFDO1FBQ2xDLENBQUMsQ0FBQyxDQUFDO0lBQ0wsQ0FBQztJQUVEOzs7T0FHRztJQUNJLEtBQUssQ0FBQyxLQUFLO1FBQ2hCLE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQyxLQUFLLEVBQUUsQ0FBQztJQUM3QixDQUFDO0lBRUQ7O09BRUc7SUFDSSxJQUFJO1FBQ1QsSUFBSSxDQUFDLE1BQU0sQ0FBQyxJQUFJLEVBQUUsQ0FBQztJQUNyQixDQUFDO0lBRUQsa0ZBQWtGO0lBQzNFLEtBQUssQ0FBQyxTQUFTO1FBQ3BCLE1BQU0sSUFBSSxDQUFDLE1BQU0sQ0FBQyxTQUFTLEVBQUUsQ0FBQztJQUNoQyxDQUFDO0lBRUQ7O09BRUc7SUFDSCxJQUFXLE9BQU87UUFDaEIsT0FBTyxJQUFJLENBQUMsTUFBTSxDQUFDLE9BQU8sQ0FBQztJQUM3QixDQUFDO0lBRUQsMERBQTBEO0lBRW5ELEtBQUssQ0FBQyxVQUFVLENBQUMsTUFBeUI7UUFDL0MsTUFBTSxJQUFJLENBQUMsTUFBTSxDQUFDLFdBQVcsQ0FBQyxPQUFPLEVBQUUsRUFBRSxNQUFNLEVBQUUsQ0FBQyxDQUFDO0lBQ3JELENBQUM7SUFFTSxLQUFLLENBQUMsU0FBUztRQUNwQixNQUFNLElBQUksQ0FBQyxNQUFNLENBQUMsV0FBVyxDQUFDLE1BQU0sRUFBRSxFQUEyQixDQUFDLENBQUM7SUFDckUsQ0FBQztJQUVNLEtBQUssQ0FBQyxZQUFZLENBQUMsTUFBMEI7UUFDbEQsTUFBTSxJQUFJLENBQUMsTUFBTSxDQUFDLFdBQVcsQ0FBQyxjQUFjLEVBQUUsRUFBRSxNQUFNLEVBQUUsQ0FBQyxDQUFDO0lBQzVELENBQUM7SUFFTSxLQUFLLENBQUMsaUJBQWlCLENBQUMsTUFBaUM7UUFDOUQsTUFBTSxJQUFJLENBQUMsTUFBTSxDQUFDLFdBQVcsQ0FBQyxtQkFBbUIsRUFBRSxFQUFFLE1BQU0sRUFBRSxDQUFDLENBQUM7SUFDakUsQ0FBQztJQUVNLEtBQUssQ0FBQyxVQUFVO1FBQ3JCLE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQyxXQUFXLENBQUMsWUFBWSxFQUFFLEVBQTJCLENBQUMsQ0FBQztJQUM1RSxDQUFDO0lBRU0sS0FBSyxDQUFDLGlCQUFpQixDQUFDLE9BQWU7UUFDNUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxRQUFRLENBQUMsT0FBTyxDQUFDLElBQUksT0FBTyxHQUFHLENBQUMsRUFBRSxDQUFDO1lBQzdDLE1BQU0sSUFBSSxLQUFLLENBQUMsOERBQThELENBQUMsQ0FBQztRQUNsRixDQUFDO1FBQ0QsTUFBTSxjQUFjLEdBQUcsSUFBSSxDQUFDLEdBQUcsQ0FDN0IsK0JBQStCLEVBQy9CLElBQUksQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUFDLENBQ3BCLENBQUM7UUFDRixPQUFPLElBQUksQ0FBQyxNQUFNLENBQUMsV0FBVyxDQUFDLG1CQUFtQixFQUFFLEVBQUUsT0FBTyxFQUFFLGNBQWMsRUFBRSxDQUFDLENBQUM7SUFDbkYsQ0FBQztJQUVNLEtBQUssQ0FBQyxhQUFhO1FBQ3hCLE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQyxXQUFXLENBQUMsZUFBZSxFQUFFLEVBQTJCLENBQUMsQ0FBQztJQUMvRSxDQUFDO0lBRU0sS0FBSyxDQUFDLDRCQUE0QixDQUN2QyxVQUE0QyxFQUFFO1FBRTlDLHVDQUF1QyxDQUFDLE9BQU8sQ0FBQyxDQUFDO1FBQ2pELE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQyxXQUFXLENBQUMsOEJBQThCLEVBQUUsT0FBTyxDQUFDLENBQUM7SUFDMUUsQ0FBQztJQUVNLEtBQUssQ0FBQywrQkFBK0IsQ0FDMUMsVUFBNEMsRUFBRTtRQUU5Qyx1Q0FBdUMsQ0FBQyxPQUFPLENBQUMsQ0FBQztRQUNqRCxPQUFPLElBQUksQ0FBQyxNQUFNLENBQUMsV0FBVyxDQUFDLGlDQUFpQyxFQUFFLE9BQU8sQ0FBQyxDQUFDO0lBQzdFLENBQUM7SUFFTSxLQUFLLENBQUMsb0JBQW9CLENBQUMsU0FBaUI7UUFDakQsTUFBTSxJQUFJLENBQUMsTUFBTSxDQUFDLFdBQVcsQ0FBQyxzQkFBc0IsRUFBRSxFQUFFLFNBQVMsRUFBRSxDQUFDLENBQUM7SUFDdkUsQ0FBQztJQUVNLEtBQUssQ0FBQyxnQkFBZ0IsQ0FBQyxTQUFpQjtRQUM3QyxNQUFNLElBQUksQ0FBQyxNQUFNLENBQUMsV0FBVyxDQUFDLGtCQUFrQixFQUFFLEVBQUUsU0FBUyxFQUFFLENBQUMsQ0FBQztJQUNuRSxDQUFDO0lBRU0sS0FBSyxDQUFDLG9CQUFvQixDQUFDLFNBQWlCO1FBQ2pELE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQyxXQUFXLENBQUMsc0JBQXNCLEVBQUUsRUFBRSxTQUFTLEVBQUUsQ0FBQyxDQUFDO0lBQ3hFLENBQUM7SUFFTSxLQUFLLENBQUMsaUJBQWlCO1FBQzVCLE1BQU0sTUFBTSxHQUFHLE1BQU0sSUFBSSxDQUFDLE1BQU0sQ0FBQyxXQUFXLENBQUMsbUJBQW1CLEVBQUUsRUFBMkIsQ0FBQyxDQUFDO1FBQy9GLE9BQU8sTUFBTSxFQUFFLEtBQUssSUFBSSxFQUFFLENBQUM7SUFDN0IsQ0FBQztJQUVNLEtBQUssQ0FBQyxxQkFBcUIsQ0FBQyxVQUFrQjtRQUNuRCxNQUFNLElBQUksQ0FBQyxNQUFNLENBQUMsV0FBVyxDQUFDLHVCQUF1QixFQUFFLEVBQUUsVUFBVSxFQUFFLENBQUMsQ0FBQztJQUN6RSxDQUFDO0lBRU0sS0FBSyxDQUFDLHlCQUF5QixDQUFDLFVBQWtCLEVBQUUsT0FBK0I7UUFDeEYsTUFBTSxJQUFJLENBQUMsTUFBTSxDQUFDLFdBQVcsQ0FBQywyQkFBMkIsRUFBRSxFQUFFLFVBQVUsRUFBRSxPQUFPLEVBQUUsQ0FBQyxDQUFDO0lBQ3RGLENBQUM7SUFFTSxLQUFLLENBQUMsZ0JBQWdCLENBQUMsSUFBWTtRQUN4QyxNQUFNLElBQUksQ0FBQyxNQUFNLENBQUMsV0FBVyxDQUFDLGtCQUFrQixFQUFFLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQztJQUM5RCxDQUFDO0lBRU0sS0FBSyxDQUFDLG1CQUFtQixDQUFDLElBQVk7UUFDM0MsTUFBTSxJQUFJLENBQUMsTUFBTSxDQUFDLFdBQVcsQ0FBQyxxQkFBcUIsRUFBRSxFQUFFLElBQUksRUFBRSxDQUFDLENBQUM7SUFDakUsQ0FBQztJQUVNLEtBQUssQ0FBQyxlQUFlLENBQUMsTUFBYyxFQUFFLElBQVksRUFBRSxHQUFXLEVBQUUsRUFBVztRQUNqRixNQUFNLElBQUksQ0FBQyxNQUFNLENBQUMsV0FBVyxDQUFDLGlCQUFpQixFQUFFLEVBQUUsTUFBTSxFQUFFLElBQUksRUFBRSxHQUFHLEVBQUUsRUFBRSxFQUFFLENBQUMsQ0FBQztJQUM5RSxDQUFDO0lBRU0sS0FBSyxDQUFDLHVCQUF1QixDQUFDLFVBQWtCO1FBQ3JELE1BQU0sSUFBSSxDQUFDLE1BQU0sQ0FBQyxXQUFXLENBQUMseUJBQXlCLEVBQUUsRUFBRSxVQUFVLEVBQUUsQ0FBQyxDQUFDO0lBQzNFLENBQUM7Q0FDRiJ9

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

@@ -75,6 +75,19 @@ export declare class SmartProxy extends plugins.EventEmitter {
      * Get certificate status for a route (async - calls Rust).
      */
     getCertificateStatus(routeName: string): Promise<IRustCertificateStatus | null>;
+    /**
+     * Lift the provisioning failure cooldown of one domain, so the next sweep
+     * (`updateRoutes()` or the renewal check) calls `certProvisionFunction` for it
+     * again instead of waiting out `certProvisionFailureCooldownMs`. Use it when the
+     * cause of a failure was resolved outside SmartProxy, for example after a
+     * certificate for the domain was issued out of band.
+     *
+     * @param domain The provisioning domain exactly as `certProvisionFunction`
+     *   receives it and `certificate-failed` reports it.
+     * @returns true if the domain was cooling down, false if it was not (never
+     *   failed, or its cooldown had already elapsed).
+     */
+    invalidateCertProvisionCooldown(domain: string): boolean;
     /**
      * Get the metrics interface.
      */
@@ -159,6 +172,7 @@ export declare class SmartProxy extends plugins.EventEmitter {
      * For routes with certificate: 'auto', call certProvisionFunction if set.
      * If the callback returns a cert object, load it into Rust.
      * If it returns 'http01', let Rust handle ACME.
+     * If it returns 'defer', leave the domain for the next sweep.
      */
     private provisionCertificatesViaCallback;
     /**