@push.rocks/smartacme 8.0.0 → 9.0.0

package/dist_ts/acme/acme.classes.http-client.d.ts

@@ -0,0 +1,36 @@
+import type { IAcmeDirectory, IAcmeHttpResponse } from './acme.interfaces.js';
+export type TAcmeLogger = (level: string, message: string, data?: any) => void;
+/**
+ * JWS-signed HTTP transport for ACME protocol.
+ * Handles nonce management, bad-nonce retries, and signed requests.
+ */
+export declare class AcmeHttpClient {
+    private directoryUrl;
+    private accountKeyPem;
+    private directory;
+    private nonce;
+    kid: string | null;
+    private logger?;
+    constructor(directoryUrl: string, accountKeyPem: string, logger?: TAcmeLogger);
+    private log;
+    /**
+     * GET the ACME directory (cached after first call)
+     */
+    getDirectory(): Promise<IAcmeDirectory>;
+    /**
+     * Fetch a fresh nonce via HEAD to newNonce
+     */
+    getNonce(): Promise<string>;
+    /**
+     * Send a JWS-signed POST request to an ACME endpoint.
+     * Handles nonce rotation and bad-nonce retries (up to 5).
+     * payload=null means POST-as-GET.
+     */
+    signedRequest(url: string, payload: any | null, options?: {
+        useJwk?: boolean;
+    }): Promise<IAcmeHttpResponse>;
+    /**
+     * Raw HTTP request using native node:https
+     */
+    private httpRequest;
+}

package/dist_ts/acme/acme.classes.http-client.js

@@ -0,0 +1,201 @@
+import * as https from 'node:https';
+import * as http from 'node:http';
+import { AcmeCrypto } from './acme.classes.crypto.js';
+import { AcmeError } from './acme.classes.error.js';
+/**
+ * JWS-signed HTTP transport for ACME protocol.
+ * Handles nonce management, bad-nonce retries, and signed requests.
+ */
+export class AcmeHttpClient {
+    constructor(directoryUrl, accountKeyPem, logger) {
+        this.directory = null;
+        this.nonce = null;
+        this.kid = null;
+        this.directoryUrl = directoryUrl;
+        this.accountKeyPem = accountKeyPem;
+        this.logger = logger;
+    }
+    log(level, message, data) {
+        if (this.logger) {
+            this.logger(level, message, data);
+        }
+    }
+    /**
+     * GET the ACME directory (cached after first call)
+     */
+    async getDirectory() {
+        if (this.directory)
+            return this.directory;
+        const response = await this.httpRequest(this.directoryUrl, 'GET');
+        if (response.status !== 200) {
+            throw new AcmeError({
+                status: response.status,
+                type: response.data?.type || '',
+                detail: `Failed to fetch ACME directory`,
+                url: this.directoryUrl,
+            });
+        }
+        this.directory = response.data;
+        return this.directory;
+    }
+    /**
+     * Fetch a fresh nonce via HEAD to newNonce
+     */
+    async getNonce() {
+        if (this.nonce) {
+            const n = this.nonce;
+            this.nonce = null;
+            return n;
+        }
+        const dir = await this.getDirectory();
+        const response = await this.httpRequest(dir.newNonce, 'HEAD');
+        const nonce = response.headers['replay-nonce'];
+        if (!nonce) {
+            throw new Error('No replay-nonce header in newNonce response');
+        }
+        return nonce;
+    }
+    /**
+     * Send a JWS-signed POST request to an ACME endpoint.
+     * Handles nonce rotation and bad-nonce retries (up to 5).
+     * payload=null means POST-as-GET.
+     */
+    async signedRequest(url, payload, options) {
+        const maxRetries = 5;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            const nonce = await this.getNonce();
+            const jwsOptions = { nonce };
+            if (options?.useJwk) {
+                jwsOptions.jwk = AcmeCrypto.getJwk(this.accountKeyPem);
+            }
+            else if (this.kid) {
+                jwsOptions.kid = this.kid;
+            }
+            else {
+                jwsOptions.jwk = AcmeCrypto.getJwk(this.accountKeyPem);
+            }
+            const jws = AcmeCrypto.createJws(this.accountKeyPem, url, payload, jwsOptions);
+            const body = JSON.stringify(jws);
+            const response = await this.httpRequest(url, 'POST', body, {
+                'Content-Type': 'application/jose+json',
+            });
+            // Save nonce from response for reuse
+            if (response.headers['replay-nonce']) {
+                this.nonce = response.headers['replay-nonce'];
+            }
+            this.log('debug', `ACME request: POST ${url} → ${response.status}`);
+            // Retry on bad-nonce
+            if (response.status === 400 &&
+                response.data?.type === 'urn:ietf:params:acme:error:badNonce') {
+                this.log('debug', `Bad nonce on attempt ${attempt + 1}, retrying`);
+                if (attempt < maxRetries) {
+                    this.nonce = null; // Force fresh nonce
+                    continue;
+                }
+            }
+            // Throw on error responses
+            if (response.status >= 400) {
+                const retryAfterRaw = response.headers['retry-after'];
+                let retryAfter = 0;
+                if (retryAfterRaw) {
+                    const parsed = parseInt(retryAfterRaw, 10);
+                    if (!isNaN(parsed)) {
+                        retryAfter = parsed;
+                    }
+                }
+                const acmeError = new AcmeError({
+                    status: response.status,
+                    type: response.data?.type || '',
+                    detail: response.data?.detail || JSON.stringify(response.data),
+                    subproblems: response.data?.subproblems,
+                    url,
+                    retryAfter,
+                });
+                if (acmeError.isRateLimited) {
+                    this.log('warn', `RATE LIMITED: ${url} (HTTP ${response.status}), Retry-After: ${retryAfter}s`, {
+                        type: acmeError.type,
+                        detail: acmeError.detail,
+                        retryAfter,
+                    });
+                }
+                else {
+                    this.log('warn', `ACME error: ${url} (HTTP ${response.status})`, {
+                        type: acmeError.type,
+                        detail: acmeError.detail,
+                    });
+                }
+                throw acmeError;
+            }
+            return response;
+        }
+        throw new Error('Max bad-nonce retries exceeded');
+    }
+    /**
+     * Raw HTTP request using native node:https
+     */
+    httpRequest(url, method, body, headers) {
+        return new Promise((resolve, reject) => {
+            const urlObj = new URL(url);
+            const isHttps = urlObj.protocol === 'https:';
+            const lib = isHttps ? https : http;
+            const requestHeaders = {
+                ...headers,
+                'User-Agent': 'smartacme-acme-client/1.0',
+            };
+            if (body) {
+                requestHeaders['Content-Length'] = Buffer.byteLength(body);
+            }
+            const options = {
+                hostname: urlObj.hostname,
+                port: urlObj.port || (isHttps ? 443 : 80),
+                path: urlObj.pathname + urlObj.search,
+                method,
+                headers: requestHeaders,
+            };
+            const req = lib.request(options, (res) => {
+                const chunks = [];
+                res.on('data', (chunk) => chunks.push(chunk));
+                res.on('end', () => {
+                    const responseBody = Buffer.concat(chunks).toString('utf-8');
+                    // Normalize headers to lowercase single-value
+                    const responseHeaders = {};
+                    for (const [key, value] of Object.entries(res.headers)) {
+                        if (typeof value === 'string') {
+                            responseHeaders[key.toLowerCase()] = value;
+                        }
+                        else if (Array.isArray(value)) {
+                            responseHeaders[key.toLowerCase()] = value[0];
+                        }
+                    }
+                    // Parse JSON if applicable, otherwise return raw string
+                    let data;
+                    const contentType = responseHeaders['content-type'] || '';
+                    if (contentType.includes('json')) {
+                        try {
+                            data = JSON.parse(responseBody);
+                        }
+                        catch {
+                            data = responseBody;
+                        }
+                    }
+                    else {
+                        data = responseBody;
+                    }
+                    resolve({
+                        status: res.statusCode || 0,
+                        headers: responseHeaders,
+                        data,
+                    });
+                });
+            });
+            req.on('error', reject);
+            req.setTimeout(30000, () => {
+                req.destroy(new Error('Request timeout'));
+            });
+            if (body)
+                req.write(body);
+            req.end();
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"acme.classes.http-client.js","sourceRoot":"","sources":["../../ts/acme/acme.classes.http-client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,YAAY,CAAC;AACpC,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAClC,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AACtD,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAKpD;;;GAGG;AACH,MAAM,OAAO,cAAc;IAQzB,YAAY,YAAoB,EAAE,aAAqB,EAAE,MAAoB;QALrE,cAAS,GAA0B,IAAI,CAAC;QACxC,UAAK,GAAkB,IAAI,CAAC;QAC7B,QAAG,GAAkB,IAAI,CAAC;QAI/B,IAAI,CAAC,YAAY,GAAG,YAAY,CAAC;QACjC,IAAI,CAAC,aAAa,GAAG,aAAa,CAAC;QACnC,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACvB,CAAC;IAEO,GAAG,CAAC,KAAa,EAAE,OAAe,EAAE,IAAU;QACpD,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;YAChB,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,CAAC,CAAC;QACpC,CAAC;IACH,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,YAAY;QAChB,IAAI,IAAI,CAAC,SAAS;YAAE,OAAO,IAAI,CAAC,SAAS,CAAC;QAC1C,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,YAAY,EAAE,KAAK,CAAC,CAAC;QAClE,IAAI,QAAQ,CAAC,MAAM,KAAK,GAAG,EAAE,CAAC;YAC5B,MAAM,IAAI,SAAS,CAAC;gBAClB,MAAM,EAAE,QAAQ,CAAC,MAAM;gBACvB,IAAI,EAAE,QAAQ,CAAC,IAAI,EAAE,IAAI,IAAI,EAAE;gBAC/B,MAAM,EAAE,gCAAgC;gBACxC,GAAG,EAAE,IAAI,CAAC,YAAY;aACvB,CAAC,CAAC;QACL,CAAC;QACD,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAC,IAAsB,CAAC;QACjD,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,QAAQ;QACZ,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC;YACrB,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;YAClB,OAAO,CAAC,CAAC;QACX,CAAC;QACD,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,YAAY,EAAE,CAAC;QACtC,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;QAC9D,MAAM,KAAK,GAAG,QAAQ,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC;QAC/C,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,MAAM,IAAI,KAAK,CAAC,6CAA6C,CAAC,CAAC;QACjE,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,aAAa,CACjB,GAAW,EACX,OAAmB,EACnB,OAA8B;QAE9B,MAAM,UAAU,GAAG,CAAC,CAAC;QAErB,KAAK,IAAI,OAAO,GAAG,CAAC,EAAE,OAAO,IAAI,UAAU,EAAE,OAAO,EAAE,EAAE,CAAC;YACvD,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,QAAQ,EAAE,CAAC;YAEpC,MAAM,UAAU,GAAkE,EAAE,KAAK,EAAE,CAAC;YAC5F,IAAI,OAAO,EAAE,MAAM,EAAE,CAAC;gBACpB,UAAU,CAAC,GAAG,GAAG,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;YACzD,CAAC;iBAAM,IAAI,IAAI,CAAC,GAAG,EAAE,CAAC;gBACpB,UAAU,CAAC,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC;YAC5B,CAAC;iBAAM,CAAC;gBACN,UAAU,CAAC,GAAG,GAAG,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;YACzD,CAAC;YAED,MAAM,GAAG,GAAG,UAAU,CAAC,SAAS,CAAC,IAAI,CAAC,aAAa,EAAE,GAAG,EAAE,OAAO,EAAE,UAAU,CAAC,CAAC;YAC/E,MAAM,IAAI,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;YAEjC,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE;gBACzD,cAAc,EAAE,uBAAuB;aACxC,CAAC,CAAC;YAEH,qCAAqC;YACrC,IAAI,QAAQ,CAAC,OAAO,CAAC,cAAc,CAAC,EAAE,CAAC;gBACrC,IAAI,CAAC,KAAK,GAAG,QAAQ,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC;YAChD,CAAC;YAED,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,sBAAsB,GAAG,MAAM,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC;YAEpE,qBAAqB;YACrB,IACE,QAAQ,CAAC,MAAM,KAAK,GAAG;gBACvB,QAAQ,CAAC,IAAI,EAAE,IAAI,KAAK,qCAAqC,EAC7D,CAAC;gBACD,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,wBAAwB,OAAO,GAAG,CAAC,YAAY,CAAC,CAAC;gBACnE,IAAI,OAAO,GAAG,UAAU,EAAE,CAAC;oBACzB,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,CAAC,oBAAoB;oBACvC,SAAS;gBACX,CAAC;YACH,CAAC;YAED,2BAA2B;YAC3B,IAAI,QAAQ,CAAC,MAAM,IAAI,GAAG,EAAE,CAAC;gBAC3B,MAAM,aAAa,GAAG,QAAQ,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC;gBACtD,IAAI,UAAU,GAAG,CAAC,CAAC;gBACnB,IAAI,aAAa,EAAE,CAAC;oBAClB,MAAM,MAAM,GAAG,QAAQ,CAAC,aAAa,EAAE,EAAE,CAAC,CAAC;oBAC3C,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC;wBACnB,UAAU,GAAG,MAAM,CAAC;oBACtB,CAAC;gBACH,CAAC;gBAED,MAAM,SAAS,GAAG,IAAI,SAAS,CAAC;oBAC9B,MAAM,EAAE,QAAQ,CAAC,MAAM;oBACvB,IAAI,EAAE,QAAQ,CAAC,IAAI,EAAE,IAAI,IAAI,EAAE;oBAC/B,MAAM,EAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,IAAI,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC;oBAC9D,WAAW,EAAE,QAAQ,CAAC,IAAI,EAAE,WAAW;oBACvC,GAAG;oBACH,UAAU;iBACX,CAAC,CAAC;gBAEH,IAAI,SAAS,CAAC,aAAa,EAAE,CAAC;oBAC5B,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,iBAAiB,GAAG,UAAU,QAAQ,CAAC,MAAM,mBAAmB,UAAU,GAAG,EAAE;wBAC9F,IAAI,EAAE,SAAS,CAAC,IAAI;wBACpB,MAAM,EAAE,SAAS,CAAC,MAAM;wBACxB,UAAU;qBACX,CAAC,CAAC;gBACL,CAAC;qBAAM,CAAC;oBACN,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,eAAe,GAAG,UAAU,QAAQ,CAAC,MAAM,GAAG,EAAE;wBAC/D,IAAI,EAAE,SAAS,CAAC,IAAI;wBACpB,MAAM,EAAE,SAAS,CAAC,MAAM;qBACzB,CAAC,CAAC;gBACL,CAAC;gBAED,MAAM,SAAS,CAAC;YAClB,CAAC;YAED,OAAO,QAAQ,CAAC;QAClB,CAAC;QAED,MAAM,IAAI,KAAK,CAAC,gCAAgC,CAAC,CAAC;IACpD,CAAC;IAED;;OAEG;IACK,WAAW,CACjB,GAAW,EACX,MAAc,EACd,IAAa,EACb,OAAgC;QAEhC,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACrC,MAAM,MAAM,GAAG,IAAI,GAAG,CAAC,GAAG,CAAC,CAAC;YAC5B,MAAM,OAAO,GAAG,MAAM,CAAC,QAAQ,KAAK,QAAQ,CAAC;YAC7C,MAAM,GAAG,GAAG,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC;YAEnC,MAAM,cAAc,GAAoC;gBACtD,GAAG,OAAO;gBACV,YAAY,EAAE,2BAA2B;aAC1C,CAAC;YACF,IAAI,IAAI,EAAE,CAAC;gBACT,cAAc,CAAC,gBAAgB,CAAC,GAAG,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;YAC7D,CAAC;YAED,MAAM,OAAO,GAAyB;gBACpC,QAAQ,EAAE,MAAM,CAAC,QAAQ;gBACzB,IAAI,EAAE,MAAM,CAAC,IAAI,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;gBACzC,IAAI,EAAE,MAAM,CAAC,QAAQ,GAAG,MAAM,CAAC,MAAM;gBACrC,MAAM;gBACN,OAAO,EAAE,cAAc;aACxB,CAAC;YAEF,MAAM,GAAG,GAAG,GAAG,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,EAAE;gBACvC,MAAM,MAAM,GAAa,EAAE,CAAC;gBAC5B,GAAG,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,KAAa,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;gBACtD,GAAG,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE;oBACjB,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;oBAE7D,8CAA8C;oBAC9C,MAAM,eAAe,GAA2B,EAAE,CAAC;oBACnD,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC;wBACvD,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;4BAC9B,eAAe,CAAC,GAAG,CAAC,WAAW,EAAE,CAAC,GAAG,KAAK,CAAC;wBAC7C,CAAC;6BAAM,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;4BAChC,eAAe,CAAC,GAAG,CAAC,WAAW,EAAE,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;wBAChD,CAAC;oBACH,CAAC;oBAED,wDAAwD;oBACxD,IAAI,IAAS,CAAC;oBACd,MAAM,WAAW,GAAG,eAAe,CAAC,cAAc,CAAC,IAAI,EAAE,CAAC;oBAC1D,IAAI,WAAW,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;wBACjC,IAAI,CAAC;4BACH,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;wBAClC,CAAC;wBAAC,MAAM,CAAC;4BACP,IAAI,GAAG,YAAY,CAAC;wBACtB,CAAC;oBACH,CAAC;yBAAM,CAAC;wBACN,IAAI,GAAG,YAAY,CAAC;oBACtB,CAAC;oBAED,OAAO,CAAC;wBACN,MAAM,EAAE,GAAG,CAAC,UAAU,IAAI,CAAC;wBAC3B,OAAO,EAAE,eAAe;wBACxB,IAAI;qBACL,CAAC,CAAC;gBACL,CAAC,CAAC,CAAC;YACL,CAAC,CAAC,CAAC;YAEH,GAAG,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;YACxB,GAAG,CAAC,UAAU,CAAC,KAAK,EAAE,GAAG,EAAE;gBACzB,GAAG,CAAC,OAAO,CAAC,IAAI,KAAK,CAAC,iBAAiB,CAAC,CAAC,CAAC;YAC5C,CAAC,CAAC,CAAC;YACH,IAAI,IAAI;gBAAE,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YAC1B,GAAG,CAAC,GAAG,EAAE,CAAC;QACZ,CAAC,CAAC,CAAC;IACL,CAAC;CACF"}

package/dist_ts/acme/acme.classes.order.d.ts

@@ -0,0 +1,40 @@
+import type { AcmeHttpClient } from './acme.classes.http-client.js';
+import type { IAcmeAuthorization, IAcmeIdentifier, IAcmeOrder } from './acme.interfaces.js';
+/**
+ * ACME order lifecycle management.
+ * Handles order creation, authorization retrieval, finalization, and certificate download.
+ */
+export declare class AcmeOrderManager {
+    private httpClient;
+    constructor(httpClient: AcmeHttpClient);
+    /**
+     * Create a new ACME order for the given identifiers
+     */
+    create(opts: {
+        identifiers: IAcmeIdentifier[];
+    }): Promise<IAcmeOrder>;
+    /**
+     * Retrieve all authorizations for an order (POST-as-GET each authorization URL)
+     */
+    getAuthorizations(order: IAcmeOrder): Promise<IAcmeAuthorization[]>;
+    /**
+     * Finalize an order by submitting the CSR.
+     * Waits for the order to reach 'valid' status.
+     * Mutates the order object with updated status and certificate URL.
+     */
+    finalize(order: IAcmeOrder, csrPem: string): Promise<void>;
+    /**
+     * Download the certificate chain (PEM) from the order's certificate URL
+     */
+    getCertificate(order: IAcmeOrder): Promise<string>;
+    /**
+     * Poll an ACME resource (order or challenge) until it reaches 'valid' or 'ready' status.
+     * Uses exponential backoff with Retry-After header support.
+     */
+    waitForValidStatus(item: {
+        url: string;
+    }, opts?: {
+        maxAttempts?: number;
+        initialDelayMs?: number;
+    }): Promise<any>;
+}

package/dist_ts/acme/acme.classes.order.js

@@ -0,0 +1,100 @@
+import { AcmeCrypto } from './acme.classes.crypto.js';
+import { AcmeError } from './acme.classes.error.js';
+/**
+ * ACME order lifecycle management.
+ * Handles order creation, authorization retrieval, finalization, and certificate download.
+ */
+export class AcmeOrderManager {
+    constructor(httpClient) {
+        this.httpClient = httpClient;
+    }
+    /**
+     * Create a new ACME order for the given identifiers
+     */
+    async create(opts) {
+        const dir = await this.httpClient.getDirectory();
+        const response = await this.httpClient.signedRequest(dir.newOrder, {
+            identifiers: opts.identifiers,
+        });
+        const order = response.data;
+        // Capture order URL from Location header
+        order.url = response.headers['location'] || '';
+        return order;
+    }
+    /**
+     * Retrieve all authorizations for an order (POST-as-GET each authorization URL)
+     */
+    async getAuthorizations(order) {
+        const authorizations = [];
+        for (const authzUrl of order.authorizations) {
+            const response = await this.httpClient.signedRequest(authzUrl, null);
+            authorizations.push(response.data);
+        }
+        return authorizations;
+    }
+    /**
+     * Finalize an order by submitting the CSR.
+     * Waits for the order to reach 'valid' status.
+     * Mutates the order object with updated status and certificate URL.
+     */
+    async finalize(order, csrPem) {
+        // Convert PEM CSR to base64url DER for ACME
+        const csrDer = AcmeCrypto.pemToBuffer(csrPem);
+        const csrB64url = csrDer.toString('base64url');
+        const response = await this.httpClient.signedRequest(order.finalize, { csr: csrB64url });
+        // Update order with response data
+        const updatedOrder = response.data;
+        order.status = updatedOrder.status;
+        if (updatedOrder.certificate) {
+            order.certificate = updatedOrder.certificate;
+        }
+        // If not yet valid, poll until it is
+        if (order.status !== 'valid' && order.url) {
+            const finalOrder = await this.waitForValidStatus({ url: order.url });
+            order.status = finalOrder.status;
+            order.certificate = finalOrder.certificate;
+        }
+    }
+    /**
+     * Download the certificate chain (PEM) from the order's certificate URL
+     */
+    async getCertificate(order) {
+        if (!order.certificate) {
+            throw new Error('Order does not have a certificate URL - finalize first');
+        }
+        const response = await this.httpClient.signedRequest(order.certificate, null);
+        // Certificate chain is returned as PEM text
+        return typeof response.data === 'string' ? response.data : response.data.toString();
+    }
+    /**
+     * Poll an ACME resource (order or challenge) until it reaches 'valid' or 'ready' status.
+     * Uses exponential backoff with Retry-After header support.
+     */
+    async waitForValidStatus(item, opts) {
+        const maxAttempts = opts?.maxAttempts ?? 30;
+        const initialDelay = opts?.initialDelayMs ?? 1000;
+        for (let i = 0; i < maxAttempts; i++) {
+            const response = await this.httpClient.signedRequest(item.url, null);
+            const body = response.data;
+            if (body.status === 'valid' || body.status === 'ready') {
+                return body;
+            }
+            if (body.status === 'invalid') {
+                const challengeError = body.challenges?.find((c) => c.error)?.error;
+                throw new AcmeError({
+                    status: 0,
+                    type: challengeError?.type || 'urn:ietf:params:acme:error:rejectedIdentifier',
+                    detail: challengeError?.detail || JSON.stringify(body),
+                    subproblems: challengeError?.subproblems,
+                    url: item.url,
+                });
+            }
+            // Respect Retry-After header, otherwise exponential backoff
+            const retryAfter = parseInt(response.headers['retry-after'] || '0', 10);
+            const delay = retryAfter > 0 ? retryAfter * 1000 : Math.min(initialDelay * Math.pow(2, i), 30000);
+            await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+        throw new Error(`Timeout waiting for valid status after ${maxAttempts} attempts`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/acme/acme.interfaces.d.ts

@@ -0,0 +1,64 @@
+/**
+ * ACME Protocol interfaces per RFC 8555
+ */
+export interface IAcmeDirectory {
+    newNonce: string;
+    newAccount: string;
+    newOrder: string;
+    newAuthz?: string;
+    revokeCert?: string;
+    keyChange?: string;
+    meta?: IAcmeDirectoryMeta;
+}
+export interface IAcmeDirectoryMeta {
+    termsOfService?: string;
+    website?: string;
+    caaIdentities?: string[];
+    externalAccountRequired?: boolean;
+}
+export interface IAcmeIdentifier {
+    type: 'dns';
+    value: string;
+}
+export interface IAcmeAccount {
+    status: string;
+    contact?: string[];
+    termsOfServiceAgreed?: boolean;
+    orders?: string;
+}
+export interface IAcmeAccountCreateRequest {
+    termsOfServiceAgreed: boolean;
+    contact?: string[];
+}
+export interface IAcmeOrder {
+    url: string;
+    status: string;
+    expires?: string;
+    identifiers: IAcmeIdentifier[];
+    authorizations: string[];
+    finalize: string;
+    certificate?: string;
+}
+export interface IAcmeAuthorization {
+    identifier: IAcmeIdentifier;
+    status: string;
+    expires?: string;
+    challenges: IAcmeChallenge[];
+    wildcard?: boolean;
+}
+export interface IAcmeChallenge {
+    type: string;
+    url: string;
+    status: string;
+    token: string;
+    validated?: string;
+}
+export interface IAcmeCsrOptions {
+    commonName: string;
+    altNames?: string[];
+}
+export interface IAcmeHttpResponse {
+    status: number;
+    headers: Record<string, string>;
+    data: any;
+}

package/dist_ts/acme/acme.interfaces.js

@@ -0,0 +1,5 @@
+/**
+ * ACME Protocol interfaces per RFC 8555
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWNtZS5pbnRlcmZhY2VzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vdHMvYWNtZS9hY21lLmludGVyZmFjZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUcifQ==

package/dist_ts/acme/index.d.ts

@@ -0,0 +1,5 @@
+export { AcmeClient, type IAcmeClientOptions } from './acme.classes.client.js';
+export { AcmeCrypto } from './acme.classes.crypto.js';
+export { AcmeError } from './acme.classes.error.js';
+export { ACME_DIRECTORY_URLS } from './acme.classes.directory.js';
+export type { IAcmeDirectory, IAcmeDirectoryMeta, IAcmeIdentifier, IAcmeAccount, IAcmeAccountCreateRequest, IAcmeOrder, IAcmeAuthorization, IAcmeChallenge, IAcmeCsrOptions, IAcmeHttpResponse, } from './acme.interfaces.js';

package/dist_ts/acme/index.js

@@ -0,0 +1,5 @@
+export { AcmeClient } from './acme.classes.client.js';
+export { AcmeCrypto } from './acme.classes.crypto.js';
+export { AcmeError } from './acme.classes.error.js';
+export { ACME_DIRECTORY_URLS } from './acme.classes.directory.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9hY21lL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQTJCLE1BQU0sMEJBQTBCLENBQUM7QUFDL0UsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBQ3RELE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUNwRCxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQyJ9

package/dist_ts/certmanagers/mongo.js

@@ -9,7 +9,6 @@ export class MongoCertManager {
      */
     constructor(mongoDescriptor) {
         this.db = new plugins.smartdata.SmartdataDb(mongoDescriptor);
-        // Use a single EasyStore document to hold all certs keyed by domainName
         this.store = new plugins.smartdata.EasyStore('smartacme-certs', this.db);
     }
     async init() {
@@ -37,4 +36,4 @@ export class MongoCertManager {
         await this.store.wipe();
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9uZ28uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9jZXJ0bWFuYWdlcnMvbW9uZ28udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLE9BQU8sTUFBTSxlQUFlLENBQUM7QUFFekMsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLDhCQUE4QixDQUFDO0FBRTdEOztHQUVHO0FBQ0gsTUFBTSxPQUFPLGdCQUFnQjtJQUkzQjs7T0FFRztJQUNILFlBQVksZUFBbUQ7UUFDN0QsSUFBSSxDQUFDLEVBQUUsR0FBRyxJQUFJLE9BQU8sQ0FBQyxTQUFTLENBQUMsV0FBVyxDQUFDLGVBQWUsQ0FBQyxDQUFDO1FBQzdELHdFQUF3RTtRQUN4RSxJQUFJLENBQUMsS0FBSyxHQUFHLElBQUksT0FBTyxDQUFDLFNBQVMsQ0FBQyxTQUFTLENBQzFDLGlCQUFpQixFQUNqQixJQUFJLENBQUMsRUFBRSxDQUNSLENBQUM7SUFDSixDQUFDO0lBRU0sS0FBSyxDQUFDLElBQUk7UUFDZixNQUFNLElBQUksQ0FBQyxFQUFFLENBQUMsSUFBSSxFQUFFLENBQUM7SUFDdkIsQ0FBQztJQUVNLEtBQUssQ0FBQyxtQkFBbUIsQ0FBQyxVQUFrQjtRQUNqRCxNQUFNLElBQUksR0FBRyxNQUFNLElBQUksQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUFDLFVBQVUsQ0FBQyxDQUFDO1FBQ2xELE9BQU8sSUFBSSxDQUFDLENBQUMsQ0FBQyxJQUFJLGFBQWEsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDO0lBQy9DLENBQUM7SUFFTSxLQUFLLENBQUMsZ0JBQWdCLENBQUMsSUFBbUI7UUFDL0MscUNBQXFDO1FBQ3JDLE1BQU0sSUFBSSxDQUFDLEtBQUssQ0FBQyxRQUFRLENBQUMsSUFBSSxDQUFDLFVBQVUsRUFBRSxFQUFFLEdBQUcsSUFBSSxFQUFFLENBQUMsQ0FBQztJQUMxRCxDQUFDO0lBRU0sS0FBSyxDQUFDLGlCQUFpQixDQUFDLFVBQWtCO1FBQy9DLE1BQU0sSUFBSSxDQUFDLEtBQUssQ0FBQyxTQUFTLENBQUMsVUFBVSxDQUFDLENBQUM7SUFDekMsQ0FBQztJQUVNLEtBQUssQ0FBQyxLQUFLO1FBQ2hCLE1BQU0sSUFBSSxDQUFDLEVBQUUsQ0FBQyxLQUFLLEVBQUUsQ0FBQztJQUN4QixDQUFDO0lBQ0Q7O09BRUc7SUFDSSxLQUFLLENBQUMsSUFBSTtRQUNmLG1DQUFtQztRQUNuQyxNQUFNLElBQUksQ0FBQyxLQUFLLENBQUMsSUFBSSxFQUFFLENBQUM7SUFDMUIsQ0FBQztDQUNGIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9uZ28uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9jZXJ0bWFuYWdlcnMvbW9uZ28udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLE9BQU8sTUFBTSxlQUFlLENBQUM7QUFFekMsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLDhCQUE4QixDQUFDO0FBRTdEOztHQUVHO0FBQ0gsTUFBTSxPQUFPLGdCQUFnQjtJQUkzQjs7T0FFRztJQUNILFlBQVksZUFBbUQ7UUFDN0QsSUFBSSxDQUFDLEVBQUUsR0FBRyxJQUFJLE9BQU8sQ0FBQyxTQUFTLENBQUMsV0FBVyxDQUFDLGVBQWUsQ0FBQyxDQUFDO1FBQzdELElBQUksQ0FBQyxLQUFLLEdBQUcsSUFBSSxPQUFPLENBQUMsU0FBUyxDQUFDLFNBQVMsQ0FDMUMsaUJBQWlCLEVBQ2pCLElBQUksQ0FBQyxFQUFFLENBQ1IsQ0FBQztJQUNKLENBQUM7SUFFTSxLQUFLLENBQUMsSUFBSTtRQUNmLE1BQU0sSUFBSSxDQUFDLEVBQUUsQ0FBQyxJQUFJLEVBQUUsQ0FBQztJQUN2QixDQUFDO0lBRU0sS0FBSyxDQUFDLG1CQUFtQixDQUFDLFVBQWtCO1FBQ2pELE1BQU0sSUFBSSxHQUFHLE1BQU0sSUFBSSxDQUFDLEtBQUssQ0FBQyxPQUFPLENBQUMsVUFBVSxDQUFDLENBQUM7UUFDbEQsT0FBTyxJQUFJLENBQUMsQ0FBQyxDQUFDLElBQUksYUFBYSxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUM7SUFDL0MsQ0FBQztJQUVNLEtBQUssQ0FBQyxnQkFBZ0IsQ0FBQyxJQUFtQjtRQUMvQyxxQ0FBcUM7UUFDckMsTUFBTSxJQUFJLENBQUMsS0FBSyxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsVUFBVSxFQUFFLEVBQUUsR0FBRyxJQUFJLEVBQUUsQ0FBQyxDQUFDO0lBQzFELENBQUM7SUFFTSxLQUFLLENBQUMsaUJBQWlCLENBQUMsVUFBa0I7UUFDL0MsTUFBTSxJQUFJLENBQUMsS0FBSyxDQUFDLFNBQVMsQ0FBQyxVQUFVLENBQUMsQ0FBQztJQUN6QyxDQUFDO0lBRU0sS0FBSyxDQUFDLEtBQUs7UUFDaEIsTUFBTSxJQUFJLENBQUMsRUFBRSxDQUFDLEtBQUssRUFBRSxDQUFDO0lBQ3hCLENBQUM7SUFDRDs7T0FFRztJQUNJLEtBQUssQ0FBQyxJQUFJO1FBQ2YsbUNBQW1DO1FBQ25DLE1BQU0sSUFBSSxDQUFDLEtBQUssQ0FBQyxJQUFJLEVBQUUsQ0FBQztJQUMxQixDQUFDO0NBQ0YifQ==

package/dist_ts/plugins.d.ts

@@ -3,24 +3,19 @@ import * as path from 'path';
 export { fs, path };
 import * as cloudflare from '@apiclient.xyz/cloudflare';
 export { cloudflare };
-import * as typedserver from '@api.global/typedserver';
-export { typedserver };
 import * as lik from '@push.rocks/lik';
 import * as smartdata from '@push.rocks/smartdata';
 import * as smartdelay from '@push.rocks/smartdelay';
 import * as smartdnsClient from '@push.rocks/smartdns/client';
-import * as smartfile from '@push.rocks/smartfile';
 import * as smartlog from '@push.rocks/smartlog';
 import * as smartnetwork from '@push.rocks/smartnetwork';
-import * as smartpromise from '@push.rocks/smartpromise';
-import * as smartrequest from '@push.rocks/smartrequest';
 import * as smartunique from '@push.rocks/smartunique';
 import * as smartstring from '@push.rocks/smartstring';
 import * as smarttime from '@push.rocks/smarttime';
-export { lik, smartdata, smartdelay, smartdnsClient, smartfile, smartlog, smartnetwork, smartpromise, smartrequest, smartunique, smartstring, smarttime, };
+export { lik, smartdata, smartdelay, smartdnsClient, smartlog, smartnetwork, smartunique, smartstring, smarttime, };
 import * as tsclass from '@tsclass/tsclass';
 export { tsclass };
-import * as acme from 'acme-client';
+import * as acme from './acme/index.js';
 export { acme };
 import * as handlers from './handlers/index.js';
 export { handlers };

package/dist_ts/plugins.js

@@ -5,30 +5,24 @@ export { fs, path };
 // @apiclient.xyz scope
 import * as cloudflare from '@apiclient.xyz/cloudflare';
 export { cloudflare };
-// @apiglobal scope
-import * as typedserver from '@api.global/typedserver';
-export { typedserver };
-// @pushrocks scope
+// @push.rocks scope
 import * as lik from '@push.rocks/lik';
 import * as smartdata from '@push.rocks/smartdata';
 import * as smartdelay from '@push.rocks/smartdelay';
 import * as smartdnsClient from '@push.rocks/smartdns/client';
-import * as smartfile from '@push.rocks/smartfile';
 import * as smartlog from '@push.rocks/smartlog';
 import * as smartnetwork from '@push.rocks/smartnetwork';
-import * as smartpromise from '@push.rocks/smartpromise';
-import * as smartrequest from '@push.rocks/smartrequest';
 import * as smartunique from '@push.rocks/smartunique';
 import * as smartstring from '@push.rocks/smartstring';
 import * as smarttime from '@push.rocks/smarttime';
-export { lik, smartdata, smartdelay, smartdnsClient, smartfile, smartlog, smartnetwork, smartpromise, smartrequest, smartunique, smartstring, smarttime, };
+export { lik, smartdata, smartdelay, smartdnsClient, smartlog, smartnetwork, smartunique, smartstring, smarttime, };
 // @tsclass scope
 import * as tsclass from '@tsclass/tsclass';
 export { tsclass };
-// third party scope
-import * as acme from 'acme-client';
+// acme protocol (custom implementation)
+import * as acme from './acme/index.js';
 export { acme };
 // local handlers for challenge types
 import * as handlers from './handlers/index.js';
 export { handlers };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYztBQUNkLE9BQU8sS0FBSyxFQUFFLE1BQU0sSUFBSSxDQUFDO0FBQ3pCLE9BQU8sS0FBSyxJQUFJLE1BQU0sTUFBTSxDQUFDO0FBRTdCLE9BQU8sRUFBRSxFQUFFLEVBQUUsSUFBSSxFQUFFLENBQUM7QUFFcEIsdUJBQXVCO0FBQ3ZCLE9BQU8sS0FBSyxVQUFVLE1BQU0sMkJBQTJCLENBQUM7QUFFeEQsT0FBTyxFQUFFLFVBQVUsRUFBRSxDQUFDO0FBRXRCLG1CQUFtQjtBQUNuQixPQUFPLEtBQUssV0FBVyxNQUFNLHlCQUF5QixDQUFDO0FBRXZELE9BQU8sRUFBRSxXQUFXLEVBQUUsQ0FBQztBQUV2QixtQkFBbUI7QUFDbkIsT0FBTyxLQUFLLEdBQUcsTUFBTSxpQkFBaUIsQ0FBQztBQUN2QyxPQUFPLEtBQUssU0FBUyxNQUFNLHVCQUF1QixDQUFDO0FBQ25ELE9BQU8sS0FBSyxVQUFVLE1BQU0sd0JBQXdCLENBQUM7QUFDckQsT0FBTyxLQUFLLGNBQWMsTUFBTSw2QkFBNkIsQ0FBQztBQUM5RCxPQUFPLEtBQUssU0FBUyxNQUFNLHVCQUF1QixDQUFDO0FBQ25ELE9BQU8sS0FBSyxRQUFRLE1BQU0sc0JBQXNCLENBQUM7QUFDakQsT0FBTyxLQUFLLFlBQVksTUFBTSwwQkFBMEIsQ0FBQztBQUN6RCxPQUFPLEtBQUssWUFBWSxNQUFNLDBCQUEwQixDQUFDO0FBQ3pELE9BQU8sS0FBSyxZQUFZLE1BQU0sMEJBQTBCLENBQUM7QUFDekQsT0FBTyxLQUFLLFdBQVcsTUFBTSx5QkFBeUIsQ0FBQztBQUN2RCxPQUFPLEtBQUssV0FBVyxNQUFNLHlCQUF5QixDQUFDO0FBQ3ZELE9BQU8sS0FBSyxTQUFTLE1BQU0sdUJBQXVCLENBQUM7QUFFbkQsT0FBTyxFQUNMLEdBQUcsRUFDSCxTQUFTLEVBQ1QsVUFBVSxFQUNWLGNBQWMsRUFDZCxTQUFTLEVBQ1QsUUFBUSxFQUNSLFlBQVksRUFDWixZQUFZLEVBQ1osWUFBWSxFQUNaLFdBQVcsRUFDWCxXQUFXLEVBQ1gsU0FBUyxHQUNWLENBQUM7QUFFRixpQkFBaUI7QUFDakIsT0FBTyxLQUFLLE9BQU8sTUFBTSxrQkFBa0IsQ0FBQztBQUU1QyxPQUFPLEVBQUUsT0FBTyxFQUFFLENBQUM7QUFFbkIsb0JBQW9CO0FBQ3BCLE9BQU8sS0FBSyxJQUFJLE1BQU0sYUFBYSxDQUFDO0FBRXBDLE9BQU8sRUFBRSxJQUFJLEVBQUUsQ0FBQztBQUNoQixxQ0FBcUM7QUFDckMsT0FBTyxLQUFLLFFBQVEsTUFBTSxxQkFBcUIsQ0FBQztBQUNoRCxPQUFPLEVBQUUsUUFBUSxFQUFFLENBQUMifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYztBQUNkLE9BQU8sS0FBSyxFQUFFLE1BQU0sSUFBSSxDQUFDO0FBQ3pCLE9BQU8sS0FBSyxJQUFJLE1BQU0sTUFBTSxDQUFDO0FBRTdCLE9BQU8sRUFBRSxFQUFFLEVBQUUsSUFBSSxFQUFFLENBQUM7QUFFcEIsdUJBQXVCO0FBQ3ZCLE9BQU8sS0FBSyxVQUFVLE1BQU0sMkJBQTJCLENBQUM7QUFFeEQsT0FBTyxFQUFFLFVBQVUsRUFBRSxDQUFDO0FBRXRCLG9CQUFvQjtBQUNwQixPQUFPLEtBQUssR0FBRyxNQUFNLGlCQUFpQixDQUFDO0FBQ3ZDLE9BQU8sS0FBSyxTQUFTLE1BQU0sdUJBQXVCLENBQUM7QUFDbkQsT0FBTyxLQUFLLFVBQVUsTUFBTSx3QkFBd0IsQ0FBQztBQUNyRCxPQUFPLEtBQUssY0FBYyxNQUFNLDZCQUE2QixDQUFDO0FBQzlELE9BQU8sS0FBSyxRQUFRLE1BQU0sc0JBQXNCLENBQUM7QUFDakQsT0FBTyxLQUFLLFlBQVksTUFBTSwwQkFBMEIsQ0FBQztBQUN6RCxPQUFPLEtBQUssV0FBVyxNQUFNLHlCQUF5QixDQUFDO0FBQ3ZELE9BQU8sS0FBSyxXQUFXLE1BQU0seUJBQXlCLENBQUM7QUFDdkQsT0FBTyxLQUFLLFNBQVMsTUFBTSx1QkFBdUIsQ0FBQztBQUVuRCxPQUFPLEVBQ0wsR0FBRyxFQUNILFNBQVMsRUFDVCxVQUFVLEVBQ1YsY0FBYyxFQUNkLFFBQVEsRUFDUixZQUFZLEVBQ1osV0FBVyxFQUNYLFdBQVcsRUFDWCxTQUFTLEdBQ1YsQ0FBQztBQUVGLGlCQUFpQjtBQUNqQixPQUFPLEtBQUssT0FBTyxNQUFNLGtCQUFrQixDQUFDO0FBRTVDLE9BQU8sRUFBRSxPQUFPLEVBQUUsQ0FBQztBQUVuQix3Q0FBd0M7QUFDeEMsT0FBTyxLQUFLLElBQUksTUFBTSxpQkFBaUIsQ0FBQztBQUV4QyxPQUFPLEVBQUUsSUFBSSxFQUFFLENBQUM7QUFDaEIscUNBQXFDO0FBQ3JDLE9BQU8sS0FBSyxRQUFRLE1BQU0scUJBQXFCLENBQUM7QUFDaEQsT0FBTyxFQUFFLFFBQVEsRUFBRSxDQUFDIn0=

package/dist_ts/smartacme.classes.smartacme.d.ts

@@ -58,6 +58,8 @@ export declare class SmartAcme {
     private pendingChallenges;
     private challengePriority;
     private interestMap;
+    private boundSigintHandler;
+    private boundSigtermHandler;
     constructor(optionsArg: ISmartAcmeOptions);
     /**
      * starts the instance
@@ -70,7 +72,7 @@ export declare class SmartAcme {
      * Stops the SmartAcme instance and closes certificate store connections.
      */
     stop(): Promise<void>;
-    /** Retry helper with exponential backoff */
+    /** Retry helper with exponential backoff and AcmeError awareness */
     private retry;
     /** Clean up pending challenges and shut down */
     private handleShutdown;