@push.rocks/smartacme 9.5.0 → 9.7.0

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

@@ -1,6 +1,7 @@
 import * as plugins from './plugins.js';
 import type { ICertManager } from './interfaces/certmanager.js';
 import { SmartacmeCert } from './smartacme.classes.cert.js';
+import type { IExactCertificateIdentity, IExactCertificateRequest, IExactIssuanceRecoveryRequest, IExactIssuanceStore, IExactIssuanceInfo, TExactCertificateResult } from './interfaces/exact-issuance.js';
 /**
  * the options for the class @see SmartAcme
  */
@@ -12,6 +13,14 @@ export interface ISmartAcmeOptions {
      */
     certManager: ICertManager;
     environment: 'production' | 'integration';
+    /** Optional explicit ACME directory, for private CAs and isolated integration. */
+    directoryUrl?: string;
+    /** Enables isolated explicit-identifier issuance with durable recovery. */
+    exactIssuanceStore?: IExactIssuanceStore;
+    /** Bounded number of admitted exact-identity operations (default 64). */
+    maxPendingExactRequests?: number;
+    /** DNS propagation grace period for explicit issuance; defaults to 60 seconds. */
+    exactDnsPropagationDelayMs?: number;
     /**
      * Optional retry/backoff configuration for transient failures
      */
@@ -66,6 +75,10 @@ export declare class SmartAcme {
     private smartdns;
     logger: plugins.smartlog.Smartlog;
     private privateKey;
+    private exactIssuer?;
+    private exactRequests;
+    private lifecycleAbort;
+    private started;
     certmanager: ICertManager;
     challengeHandlers: plugins.handlers.IChallengeHandler<any>[];
     private certmatcher;
@@ -92,6 +105,15 @@ export declare class SmartAcme {
      * Stops the SmartAcme instance and closes certificate store connections.
      */
     stop(): Promise<void>;
+    /** Bind durable work to the current account and issuer without creating an order. */
+    getCertificateIdentity(request: IExactCertificateRequest): IExactCertificateIdentity;
+    /** Ensure a certificate whose SANs exactly match the explicit identifiers. */
+    getCertificateForIdentifiers(request: IExactCertificateRequest): Promise<TExactCertificateResult>;
+    getCertificateIssuanceStatus(request: IExactCertificateRequest): Promise<IExactIssuanceInfo | null>;
+    /** Administrative recovery; embedding services must authorize the caller. */
+    recoverCertificateIssuance(request: IExactIssuanceRecoveryRequest): Promise<TExactCertificateResult>;
+    private requireExactIssuer;
+    private runExact;
     /** Retry helper with exponential backoff and AcmeError awareness */
     private retry;
     /** Clean up pending challenges and shut down */

package/dist_ts/smartacme.classes.smartacme.js

@@ -2,6 +2,7 @@ import * as plugins from './plugins.js';
 import { SmartacmeCertMatcher } from './smartacme.classes.certmatcher.js';
 import { commitinfo } from './00_commitinfo_data.js';
 import { SmartacmeCert } from './smartacme.classes.cert.js';
+import { ExactCertificateIssuer } from './classes.exact-certificate-issuer.js';
 const CERT_ISSUANCE_STEPS = [
     { name: 'prepare', description: 'Creating ACME order', percentage: 10 },
     { name: 'authorize', description: 'Solving ACME challenges', percentage: 40 },
@@ -27,12 +28,21 @@ export class SmartAcme {
     }
     constructor(optionsArg) {
         this.smartdns = new plugins.smartdnsClient.Smartdns({});
+        this.exactRequests = new Map();
+        this.lifecycleAbort = new AbortController();
+        this.started = false;
         // track pending DNS challenges for graceful shutdown
         this.pendingChallenges = [];
         // bound signal handlers so they can be removed on stop()
         this.boundSigintHandler = null;
         this.boundSigtermHandler = null;
         this.options = optionsArg;
+        if (!Number.isSafeInteger(optionsArg.maxPendingExactRequests ?? 64)
+            || (optionsArg.maxPendingExactRequests ?? 64) < 1
+            || !Number.isSafeInteger(optionsArg.exactDnsPropagationDelayMs ?? 60000)
+            || (optionsArg.exactDnsPropagationDelayMs ?? 60000) < 0) {
+            throw new Error('Invalid explicit issuance admission or propagation limits');
+        }
         this.logger = plugins.smartlog.Smartlog.createForCommitinfo(commitinfo);
         // enable console output for structured logging
         this.logger.enableConsole();
@@ -61,9 +71,13 @@ export class SmartAcme {
             maxConcurrent: 1,
             resultSharingMode: 'share-latest',
             constraintKeyForExecution: (_task, input) => {
+                if (input?.exact)
+                    return null;
                 return input?.certDomainName ?? null;
             },
             shouldExecute: async (_task, input) => {
+                if (input?.exact)
+                    return true;
                 if (!input?.certDomainName || !this.certmanager)
                     return true;
                 if (input.forceRenew)
@@ -92,6 +106,12 @@ export class SmartAcme {
             constraintKeyForExecution: () => 'account',
         });
         this.taskManager.addConstraintGroup(certDomainMutex);
+        // One fixed key reserves a bounded share of global capacity for testing.
+        // Exact results contain private keys and must never enter result-sharing caches.
+        this.taskManager.addConstraintGroup(new plugins.taskbuffer.TaskConstraintGroup({
+            name: 'exact-issuance-concurrency', maxConcurrent: 2,
+            constraintKeyForExecution: (_task, input) => input?.exact ? 'exact' : null,
+        }));
         this.taskManager.addConstraintGroup(acmeGlobalConcurrency);
         this.taskManager.addConstraintGroup(acmeAccountRateLimit);
         // Create the single reusable certificate issuance task
@@ -99,6 +119,12 @@ export class SmartAcme {
             name: 'cert-issuance',
             steps: CERT_ISSUANCE_STEPS,
             taskFunction: async (input) => {
+                if (input.exact) {
+                    const issuer = this.requireExactIssuer();
+                    return input.exact.recovery
+                        ? issuer.recover(input.exact.recovery)
+                        : issuer.run(input.exact.request);
+                }
                 return this.performCertificateIssuance(input);
             },
         });
@@ -111,8 +137,33 @@ export class SmartAcme {
      * ```
      */
     async start() {
+        if (this.started)
+            throw new Error('SmartAcme is already started');
+        this.lifecycleAbort = new AbortController();
         this.privateKey =
             this.options.accountPrivateKey || plugins.acme.AcmeCrypto.createRsaPrivateKey();
+        const directoryUrl = this.options.directoryUrl ?? (this.options.environment === 'production'
+            ? plugins.acme.ACME_DIRECTORY_URLS.letsencrypt.production
+            : plugins.acme.ACME_DIRECTORY_URLS.letsencrypt.staging);
+        const directory = new URL(directoryUrl);
+        if (directory.username || directory.password || directory.hash
+            || (directory.protocol !== 'https:' && !(directory.protocol === 'http:'
+                && ['localhost', '127.0.0.1', '[::1]'].includes(directory.hostname)))) {
+            throw new Error('An HTTPS ACME directory or an explicit loopback test directory is required');
+        }
+        if (this.options.exactIssuanceStore && !this.options.accountPrivateKey) {
+            const accountId = plugins.crypto.createHash('sha256')
+                .update(JSON.stringify([directoryUrl, this.options.accountEmail.trim().toLowerCase()])).digest('hex');
+            const store = this.options.exactIssuanceStore;
+            let storedKey = await store.getAccountKey(accountId);
+            if (!storedKey) {
+                await store.createAccountKey(accountId, this.privateKey);
+                storedKey = await store.getAccountKey(accountId);
+            }
+            if (!storedKey)
+                throw new Error('ACME account key could not be retained durably');
+            this.privateKey = storedKey;
+        }
         // Initialize certificate manager
         if (!this.options.certManager) {
             throw new Error('You must provide a certManager via options.certManager');
@@ -123,15 +174,9 @@ export class SmartAcme {
         this.certmatcher = new SmartacmeCertMatcher();
         // ACME Client
         this.client = new plugins.acme.AcmeClient({
-            directoryUrl: (() => {
-                if (this.options.environment === 'production') {
-                    return plugins.acme.ACME_DIRECTORY_URLS.letsencrypt.production;
-                }
-                else {
-                    return plugins.acme.ACME_DIRECTORY_URLS.letsencrypt.staging;
-                }
-            })(),
+            directoryUrl,
             accountKeyPem: this.privateKey,
+            signal: this.lifecycleAbort.signal,
             logger: (level, message, data) => {
                 this.logger.log(level, message, data);
             },
@@ -143,6 +188,15 @@ export class SmartAcme {
         });
         // Start the task manager
         await this.taskManager.start();
+        if (this.options.exactIssuanceStore) {
+            this.exactIssuer = new ExactCertificateIssuer({
+                store: this.options.exactIssuanceStore, client: this.client, directoryUrl,
+                accountThumbprint: plugins.acme.AcmeCrypto.getJwkThumbprint(plugins.acme.AcmeCrypto.getJwk(this.privateKey)),
+                dns: this.smartdns, handlers: this.challengeHandlers, signal: this.lifecycleAbort.signal,
+                dnsPropagationDelayMs: this.options.exactDnsPropagationDelayMs ?? 60000,
+            });
+        }
+        this.started = true;
         // Setup graceful shutdown handlers (store references for removal in stop())
         this.boundSigintHandler = () => this.handleSignal('SIGINT');
         this.boundSigtermHandler = () => this.handleSignal('SIGTERM');
@@ -153,6 +207,8 @@ export class SmartAcme {
      * Stops the SmartAcme instance and closes certificate store connections.
      */
     async stop() {
+        this.started = false;
+        this.lifecycleAbort.abort();
         // Remove signal handlers so the process can exit cleanly
         if (this.boundSigintHandler) {
             process.removeListener('SIGINT', this.boundSigintHandler);
@@ -162,8 +218,13 @@ export class SmartAcme {
             process.removeListener('SIGTERM', this.boundSigtermHandler);
             this.boundSigtermHandler = null;
         }
-        // Stop the task manager
+        // Observe active requests before rejecting queued work. The task manager
+        // must close its queue before we drain callers waiting on that queue.
+        const pendingExactRequests = Promise.allSettled([...this.exactRequests.values()]);
         await this.taskManager.stop();
+        await pendingExactRequests;
+        this.exactRequests.clear();
+        this.exactIssuer = undefined;
         // Destroy ACME HTTP transport (closes keep-alive sockets)
         if (this.client) {
             this.client.destroy();
@@ -176,6 +237,66 @@ export class SmartAcme {
             await this.certmanager.close();
         }
     }
+    /** Bind durable work to the current account and issuer without creating an order. */
+    getCertificateIdentity(request) {
+        return this.requireExactIssuer().identity(request);
+    }
+    /** Ensure a certificate whose SANs exactly match the explicit identifiers. */
+    async getCertificateForIdentifiers(request) {
+        return await this.runExact(request);
+    }
+    async getCertificateIssuanceStatus(request) {
+        return await this.requireExactIssuer().status(request);
+    }
+    /** Administrative recovery; embedding services must authorize the caller. */
+    async recoverCertificateIssuance(request) {
+        return await this.runExact(request, request);
+    }
+    requireExactIssuer() {
+        if (!this.started || !this.exactIssuer)
+            throw new Error('SmartAcme explicit issuance is not running or configured');
+        return this.exactIssuer;
+    }
+    async runExact(request, recovery) {
+        const issuer = this.requireExactIssuer();
+        const identity = issuer.identity(request);
+        const recoverySnapshot = recovery ? {
+            namespace: identity.namespace, identifiers: [...identity.identifiers],
+            issuanceId: recovery.issuanceId, expectedRevision: recovery.expectedRevision, action: recovery.action,
+        } : undefined;
+        const existing = this.exactRequests.get(identity.certificateKey);
+        if (existing) {
+            if (recovery)
+                throw new Error('Issuance is running; recover after its current operation completes');
+            return await existing;
+        }
+        if (this.exactRequests.size >= (this.options.maxPendingExactRequests ?? 64)) {
+            throw new Error('Explicit issuance admission limit reached');
+        }
+        const operation = (async () => {
+            if (!recovery) {
+                const cached = await issuer.cached(identity);
+                if (cached)
+                    return cached;
+            }
+            this.lifecycleAbort.signal.throwIfAborted();
+            const result = await this.taskManager.triggerTaskConstrained(this.certIssuanceTask, {
+                certDomainName: identity.certificateKey, domainArg: identity.identifiers[0],
+                isWildcardRequest: false, includeWildcard: false, forceRenew: false,
+                exact: { request: { namespace: identity.namespace, identifiers: identity.identifiers }, recovery: recoverySnapshot },
+            });
+            if (!result)
+                throw new Error('Explicit issuance completed without a result');
+            return result;
+        })();
+        this.exactRequests.set(identity.certificateKey, operation);
+        try {
+            return await operation;
+        }
+        finally {
+            this.exactRequests.delete(identity.certificateKey);
+        }
+    }
     /** Retry helper with exponential backoff and AcmeError awareness */
     async retry(operation, operationName = 'operation') {
         let attempt = 0;
@@ -210,12 +331,12 @@ export class SmartAcme {
     }
     /** Clean up pending challenges and shut down */
     async handleShutdown() {
-        for (const input of [...this.pendingChallenges]) {
+        for (const { input, context } of [...this.pendingChallenges]) {
             const type = input.type;
             const handler = this.challengeHandlers.find((h) => h.getSupportedTypes().includes(type));
             if (handler) {
                 try {
-                    await handler.cleanup(input);
+                    await handler.cleanup(input, { ...context });
                     await this.logger.log('info', `Removed pending ${type} challenge during shutdown`, input);
                 }
                 catch (err) {
@@ -329,6 +450,10 @@ export class SmartAcme {
         const order = await this.retry(() => this.client.createOrder({
             identifiers,
         }), 'createOrder');
+        const challengeContext = {
+            operationId: plugins.crypto.createHash('sha256')
+                .update(JSON.stringify(['smartacme-legacy-challenge-v1', order.url])).digest('hex'),
+        };
         // ── Step: authorize ───────────────────────────────────────────────────
         this.certIssuanceTask.notifyStep('authorize');
         /* Get authorizations and select challenges */
@@ -371,9 +496,9 @@ export class SmartAcme {
             else {
                 challengeInput = { type, keyAuthorization: keyAuth, ...selectedChallengeArg };
             }
-            this.pendingChallenges.push(challengeInput);
+            this.pendingChallenges.push({ input: challengeInput, context: challengeContext });
             try {
-                await this.retry(() => handler.prepare(challengeInput), `${type}.prepare`);
+                await this.retry(() => handler.prepare(challengeInput, { ...challengeContext }), `${type}.prepare`);
                 if (type === 'dns-01') {
                     const dnsInput = challengeInput;
                     await this.retry(() => this.smartdns.checkUntilAvailable(dnsInput.hostName, 'TXT', dnsInput.challenge, 100, 5000), `${type}.propagation`);
@@ -390,13 +515,13 @@ export class SmartAcme {
             }
             finally {
                 try {
-                    await this.retry(() => handler.cleanup(challengeInput), `${type}.cleanup`);
+                    await this.retry(() => handler.cleanup(challengeInput, { ...challengeContext }), `${type}.cleanup`);
                 }
                 catch (err) {
                     await this.logger.log('error', `Error during ${type}.cleanup`, err);
                 }
                 finally {
-                    this.pendingChallenges = this.pendingChallenges.filter((c) => c !== challengeInput);
+                    this.pendingChallenges = this.pendingChallenges.filter((c) => c.input !== challengeInput);
                 }
             }
         }
@@ -446,4 +571,4 @@ export class SmartAcme {
         return newCertificate ?? certRecord;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"smartacme.classes.smartacme.js","sourceRoot":"","sources":["../../ts/smartacme.classes.smartacme.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"smartacme.classes.smartacme.js","sourceRoot":"","sources":["../../ts/smartacme.classes.smartacme.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,16 +1,11 @@
 {
   "name": "@push.rocks/smartacme",
-  "version": "9.5.0",
+  "version": "9.7.0",
   "private": false,
   "description": "A TypeScript-based ACME client and server for certificate management with built-in CA, supporting LetsEncrypt and custom ACME authorities.",
   "main": "dist_ts/index.js",
   "typings": "dist_ts/index.d.ts",
   "type": "module",
-  "scripts": {
-    "test": "(tstest test/ --verbose --logfile --timeout 600)",
-    "build": "(tsbuild tsfolders)",
-    "buildDocs": "tsdoc"
-  },
   "repository": {
     "type": "git",
     "url": "https://code.foss.global/push.rocks/smartacme.git"
@@ -55,16 +50,16 @@
     "@push.rocks/smartstring": "^4.1.0",
     "@push.rocks/smarttime": "^4.2.3",
     "@push.rocks/smartunique": "^3.0.9",
-    "@push.rocks/taskbuffer": "^8.0.2",
+    "@push.rocks/taskbuffer": "^9.0.2",
     "@tsclass/tsclass": "^9.5.0",
     "reflect-metadata": "^0.2.2"
   },
   "devDependencies": {
-    "@git.zone/tsbuild": "^4.4.0",
-    "@git.zone/tsrun": "^2.0.2",
-    "@git.zone/tstest": "^3.6.3",
+    "@git.zone/tsbuild": "^4.4.2",
+    "@git.zone/tsrun": "^2.0.6",
+    "@git.zone/tstest": "^5.0.0",
     "@push.rocks/qenv": "^6.1.3",
-    "@types/node": "^25.5.0"
+    "@types/node": "26.4.1"
   },
   "files": [
     "ts/**/*",
@@ -81,8 +76,9 @@
   "browserslist": [
     "last 1 chrome versions"
   ],
-  "packageManager": "pnpm@10.7.0+sha512.6b865ad4b62a1d9842b61d674a393903b871d9244954f652b8842c2b553c72176b278f64c463e52d40fff8aba385c235c8c9ecf5cc7de4fd78b8bb6d49633ab6",
-  "pnpm": {
-    "overrides": {}
+  "scripts": {
+    "test": "(tstest test/ --verbose --logfile --timeout 600)",
+    "build": "(tsbuild tsfolders)",
+    "buildDocs": "tsdoc"
   }
-}
+}

package/readme.md

@@ -48,7 +48,7 @@ await smartAcme.start();
 // 4. Get a certificate
 const cert = await smartAcme.getCertificateForDomain('example.com');
 console.log(cert.publicKey);  // PEM certificate chain
-console.log(cert.privateKey); // PEM private key
+// Supply cert.privateKey directly to your TLS consumer; never log it.
 
 // 5. Clean up
 await smartAcme.stop();
@@ -74,6 +74,10 @@ interface ISmartAcmeOptions {
   maxConcurrentIssuances?: number;           // Global cap on parallel ACME ops (default: 5)
   maxOrdersPerWindow?: number;               // Max orders in sliding window (default: 250)
   orderWindowMs?: number;                    // Sliding window duration in ms (default: 3 hours)
+  directoryUrl?: string;                     // Explicit HTTPS CA directory; loopback HTTP for tests
+  exactIssuanceStore?: IExactIssuanceStore;   // Durable exact-name account/order/certificate adapter
+  maxPendingExactRequests?: number;          // Bounded in-flight exact identities (default: 64)
+  exactDnsPropagationDelayMs?: number;       // DNS propagation grace period (default: 60000)
 }
 ```
 
@@ -95,6 +99,91 @@ const wildcardCert = await smartAcme.getCertificateForDomain('*.example.com');
 
 Certificates are automatically cached and reused when still valid. Renewal happens automatically when a certificate is within 10 days of expiration. The actual X.509 expiry date is parsed from the issued certificate, ensuring renewal timing is precise.
 
+### Exact identifiers and durable order recovery
+
+Use `getCertificateForIdentifiers()` for independently authorized hostnames. It
+supports nested names such as `alice.dev.example.com`, canonicalizes IDNA, case,
+and trailing dots, and never adds a parent or wildcard identifier. Explicit
+wildcards remain supported when deliberately included by the caller. The
+embedding application must authorize the entire requested identifier set.
+
+Configure `exactIssuanceStore` before `start()`. Its public `IExactIssuanceStore`
+interface owns durable account keys, revision-checked issuance records, and
+completed certificates. `createAccountKey()` must insert only if absent;
+`compareAndSetIssuance()` must atomically insert on a null revision or replace
+only the expected revision. Acknowledgement means the write is durable. No
+filesystem or implicit in-memory persistence fallback is provided.
+
+```typescript
+// smartAcme has been started with your durable exactIssuanceStore adapter.
+const request = {
+  namespace: 'testing-grant:stable-grant-id',
+  identifiers: ['alice.dev.example.com'],
+};
+const result = await smartAcme.getCertificateForIdentifiers(request);
+if (result.status === 'ready') {
+  // Pass result.certificate.publicKey and .privateKey to the authorized TLS consumer.
+  // Metadata includes validFrom, validUntil, and renewAfter in milliseconds.
+} else {
+  // Persist a job reference and poll according to your worker policy.
+  console.log(result.issuance.status); // Safe projection; contains no secret material.
+}
+```
+
+Certificate identity binds the namespace, sorted exact identifiers, directory
+URL, and account thumbprint. Different namespaces never reuse private keys.
+Cached material is checked for the exact SAN set, matching private key, and
+validity before delivery. Valid cache reads consume no issuance slot. Renewal
+is on demand at `renewAfter`, with a new key and order; there is no background
+renewal timer. The renewal margin is the smaller of ten days or one third of
+the certificate lifetime.
+
+The exact path requires DNS-01 and verifies handler support before creating an
+order. Handler prepare/cleanup must be idempotent and cleanup must remove only
+the supplied TXT value. Cleanup intent is retained until cleanup succeeds.
+Exact work has two concurrent slots within the configured global capacity,
+bounded admission, and an in-flight map that releases entries on completion.
+Secret-bearing results do not enter Taskbuffer's result-sharing cache.
+For exact issuance, `stop()` closes admission, rejects queued callers, aborts active protocol
+requests and propagation waits, and drains their cleanup before closing the
+transport and storage. Custom challenge callbacks must settle for shutdown to
+finish; their external effects remain the callback owner's responsibility.
+
+`getCertificateIdentity(request)` binds a durable job to the current namespace,
+identifiers, issuer, and account without placing an order.
+`getCertificateIssuanceStatus(request)` returns only safe status metadata.
+`recoverCertificateIssuance({ ...request, issuanceId, expectedRevision, action })`
+accepts `recheck`, `retry-proven-unapplied`, or `abandon`; the embedding service
+must authorize administrative recovery. An acknowledged order retains its
+original key, CSR, and order handle through restarts. Lost order-creation or
+finalization responses produce `indeterminate` rather than automatically
+placing another order. `recheck` reads the acknowledged order and can recover
+an issued certificate. A rate-limit rejection of order creation is the only
+currently supported proof permitting `retry-proven-unapplied`; its retry time
+must first elapse. `abandon` retains `abandoned_unverified` evidence and does
+not authorize a replacement order or claim CA rollback.
+
+Store adapters must keep unresolved issuance evidence and enforce retention
+and admission quotas at their application boundary. Issuance records contain
+private keys, CSRs, and challenge values: do not serialize them into status
+APIs or logs. Credential/grant revocation belongs to the embedding application;
+it cannot erase material previously delivered to a client.
+
+Custom challenge handlers receive an optional second `IChallengeContext` argument
+on `prepare`, `verify`, and `cleanup`. SmartAcme always supplies its opaque
+`operationId`: it stays the same for an order's retries, cleanup, and exact
+issuance recovery after restart. Renewal and isolated issuances get separate
+owners. Combine it with the challenge type and input to key durable resource
+intent; do not infer ownership from a hostname or TXT value alone. Existing
+handlers accepting one argument remain supported. Built-in DNS adapters retain
+the ownership semantics of their configured provider.
+
+The normal `pnpm test` suite uses isolated protocol fixtures. The live Cloudflare
+test is skipped unless `SMARTACME_LIVE_DNS_TEST=1` is explicitly set. With separate
+authorization for public DNS changes and staging-CA issuance, run
+`SMARTACME_LIVE_DNS_TEST=1 pnpm exec tstest test/test.smartacme.integration.ts --verbose --logfile --timeout 600`.
+That test uses the `CF_TOKEN` credential and issues for `bleu.de` and `*.bleu.de`.
+
 ### 📦 Certificate Object
 
 The returned `SmartacmeCert` (also exported as `Cert`) object has these properties:

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@push.rocks/smartacme',
-  version: '9.5.0',
+  version: '9.7.0',
   description: 'A TypeScript-based ACME client and server for certificate management with built-in CA, supporting LetsEncrypt and custom ACME authorities.'
 }

package/ts/acme/acme.classes.client.ts

@@ -17,6 +17,7 @@ export interface IAcmeClientOptions {
   directoryUrl: string;
   accountKeyPem: string;
   logger?: TAcmeLogger;
+  signal?: AbortSignal;
 }
 
 /**
@@ -35,7 +36,7 @@ export class AcmeClient {
   static crypto = AcmeCrypto;
 
   constructor(options: IAcmeClientOptions) {
-    this.httpClient = new AcmeHttpClient(options.directoryUrl, options.accountKeyPem, options.logger);
+    this.httpClient = new AcmeHttpClient(options.directoryUrl, options.accountKeyPem, options.logger, options.signal);
     this.account = new AcmeAccount(this.httpClient);
     this.orderManager = new AcmeOrderManager(this.httpClient);
     this.challengeManager = new AcmeChallengeManager(this.httpClient, options.accountKeyPem);
@@ -55,6 +56,10 @@ export class AcmeClient {
     return this.orderManager.create(opts);
   }
 
+  async getOrder(url: string): Promise<IAcmeOrder> {
+    return this.orderManager.get(url);
+  }
+
   /**
    * Get all authorizations for an order
    */