@push.rocks/smartacme 6.1.3 → 7.2.1

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@push.rocks/smartacme',
-    version: '6.1.3',
+    version: '7.2.1',
     description: 'A TypeScript-based ACME client for LetsEncrypt certificate management with a focus on simplicity and power.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSx1QkFBdUI7SUFDN0IsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLDZHQUE2RztDQUMzSCxDQUFBIn0=

package/dist_ts/certmanagers/index.d.ts

@@ -0,0 +1,2 @@
+export * from './memory.js';
+export * from './mongo.js';

package/dist_ts/certmanagers/index.js

@@ -0,0 +1,3 @@
+export * from './memory.js';
+export * from './mongo.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9jZXJ0bWFuYWdlcnMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxZQUFZLENBQUMifQ==

package/dist_ts/certmanagers/memory.d.ts

@@ -0,0 +1,18 @@
+import type { ICertManager } from '../interfaces/certmanager.js';
+import { SmartacmeCert } from '../smartacme.classes.cert.js';
+/**
+ * In-memory certificate manager for mongoless mode.
+ * Stores certificates in memory only and does not connect to MongoDB.
+ */
+export declare class MemoryCertManager implements ICertManager {
+    private certs;
+    init(): Promise<void>;
+    retrieveCertificate(domainName: string): Promise<SmartacmeCert | null>;
+    storeCertificate(cert: SmartacmeCert): Promise<void>;
+    deleteCertificate(domainName: string): Promise<void>;
+    close(): Promise<void>;
+    /**
+     * Wipe all certificates from the in-memory store (for testing)
+     */
+    wipe(): Promise<void>;
+}

package/dist_ts/certmanagers/memory.js

@@ -0,0 +1,33 @@
+import * as plugins from '../smartacme.plugins.js';
+import { SmartacmeCert } from '../smartacme.classes.cert.js';
+/**
+ * In-memory certificate manager for mongoless mode.
+ * Stores certificates in memory only and does not connect to MongoDB.
+ */
+export class MemoryCertManager {
+    constructor() {
+        this.certs = new Map();
+    }
+    async init() {
+        // no-op for in-memory store
+    }
+    async retrieveCertificate(domainName) {
+        return this.certs.get(domainName) ?? null;
+    }
+    async storeCertificate(cert) {
+        this.certs.set(cert.domainName, cert);
+    }
+    async deleteCertificate(domainName) {
+        this.certs.delete(domainName);
+    }
+    async close() {
+        // no-op
+    }
+    /**
+     * Wipe all certificates from the in-memory store (for testing)
+     */
+    async wipe() {
+        this.certs.clear();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVtb3J5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vdHMvY2VydG1hbmFnZXJzL21lbW9yeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssT0FBTyxNQUFNLHlCQUF5QixDQUFDO0FBRW5ELE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSw4QkFBOEIsQ0FBQztBQUU3RDs7O0dBR0c7QUFDSCxNQUFNLE9BQU8saUJBQWlCO0lBQTlCO1FBQ1UsVUFBSyxHQUErQixJQUFJLEdBQUcsRUFBRSxDQUFDO0lBNEJ4RCxDQUFDO0lBekJRLEtBQUssQ0FBQyxJQUFJO1FBQ2YsNEJBQTRCO0lBQzlCLENBQUM7SUFFTSxLQUFLLENBQUMsbUJBQW1CLENBQUMsVUFBa0I7UUFDakQsT0FBTyxJQUFJLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxVQUFVLENBQUMsSUFBSSxJQUFJLENBQUM7SUFDNUMsQ0FBQztJQUVNLEtBQUssQ0FBQyxnQkFBZ0IsQ0FBQyxJQUFtQjtRQUMvQyxJQUFJLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsVUFBVSxFQUFFLElBQUksQ0FBQyxDQUFDO0lBQ3hDLENBQUM7SUFFTSxLQUFLLENBQUMsaUJBQWlCLENBQUMsVUFBa0I7UUFDL0MsSUFBSSxDQUFDLEtBQUssQ0FBQyxNQUFNLENBQUMsVUFBVSxDQUFDLENBQUM7SUFDaEMsQ0FBQztJQUVNLEtBQUssQ0FBQyxLQUFLO1FBQ2hCLFFBQVE7SUFDVixDQUFDO0lBQ0Q7O09BRUc7SUFDSSxLQUFLLENBQUMsSUFBSTtRQUNmLElBQUksQ0FBQyxLQUFLLENBQUMsS0FBSyxFQUFFLENBQUM7SUFDckIsQ0FBQztDQUNGIn0=

package/dist_ts/certmanagers/mongo.d.ts

@@ -0,0 +1,23 @@
+import * as plugins from '../smartacme.plugins.js';
+import type { ICertManager } from '../interfaces/certmanager.js';
+import { SmartacmeCert } from '../smartacme.classes.cert.js';
+/**
+ * MongoDB-backed certificate manager using EasyStore from smartdata.
+ */
+export declare class MongoCertManager implements ICertManager {
+    private db;
+    private store;
+    /**
+     * @param mongoDescriptor MongoDB connection settings
+     */
+    constructor(mongoDescriptor: plugins.smartdata.IMongoDescriptor);
+    init(): Promise<void>;
+    retrieveCertificate(domainName: string): Promise<SmartacmeCert | null>;
+    storeCertificate(cert: SmartacmeCert): Promise<void>;
+    deleteCertificate(domainName: string): Promise<void>;
+    close(): Promise<void>;
+    /**
+     * Wipe all certificates from the persistent store (for integration testing)
+     */
+    wipe(): Promise<void>;
+}

package/dist_ts/certmanagers/mongo.js

@@ -0,0 +1,40 @@
+import * as plugins from '../smartacme.plugins.js';
+import { SmartacmeCert } from '../smartacme.classes.cert.js';
+/**
+ * MongoDB-backed certificate manager using EasyStore from smartdata.
+ */
+export class MongoCertManager {
+    /**
+     * @param mongoDescriptor MongoDB connection settings
+     */
+    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() {
+        await this.db.init();
+    }
+    async retrieveCertificate(domainName) {
+        const data = await this.store.readKey(domainName);
+        return data ? new SmartacmeCert(data) : null;
+    }
+    async storeCertificate(cert) {
+        // write plain object for persistence
+        await this.store.writeKey(cert.domainName, { ...cert });
+    }
+    async deleteCertificate(domainName) {
+        await this.store.deleteKey(domainName);
+    }
+    async close() {
+        await this.db.close();
+    }
+    /**
+     * Wipe all certificates from the persistent store (for integration testing)
+     */
+    async wipe() {
+        // clear all keys in the easy store
+        await this.store.wipe();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9uZ28uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9jZXJ0bWFuYWdlcnMvbW9uZ28udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLE9BQU8sTUFBTSx5QkFBeUIsQ0FBQztBQUVuRCxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sOEJBQThCLENBQUM7QUFFN0Q7O0dBRUc7QUFDSCxNQUFNLE9BQU8sZ0JBQWdCO0lBSTNCOztPQUVHO0lBQ0gsWUFBWSxlQUFtRDtRQUM3RCxJQUFJLENBQUMsRUFBRSxHQUFHLElBQUksT0FBTyxDQUFDLFNBQVMsQ0FBQyxXQUFXLENBQUMsZUFBZSxDQUFDLENBQUM7UUFDN0Qsd0VBQXdFO1FBQ3hFLElBQUksQ0FBQyxLQUFLLEdBQUcsSUFBSSxPQUFPLENBQUMsU0FBUyxDQUFDLFNBQVMsQ0FDMUMsaUJBQWlCLEVBQ2pCLElBQUksQ0FBQyxFQUFFLENBQ1IsQ0FBQztJQUNKLENBQUM7SUFFTSxLQUFLLENBQUMsSUFBSTtRQUNmLE1BQU0sSUFBSSxDQUFDLEVBQUUsQ0FBQyxJQUFJLEVBQUUsQ0FBQztJQUN2QixDQUFDO0lBRU0sS0FBSyxDQUFDLG1CQUFtQixDQUFDLFVBQWtCO1FBQ2pELE1BQU0sSUFBSSxHQUFHLE1BQU0sSUFBSSxDQUFDLEtBQUssQ0FBQyxPQUFPLENBQUMsVUFBVSxDQUFDLENBQUM7UUFDbEQsT0FBTyxJQUFJLENBQUMsQ0FBQyxDQUFDLElBQUksYUFBYSxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUM7SUFDL0MsQ0FBQztJQUVNLEtBQUssQ0FBQyxnQkFBZ0IsQ0FBQyxJQUFtQjtRQUMvQyxxQ0FBcUM7UUFDckMsTUFBTSxJQUFJLENBQUMsS0FBSyxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsVUFBVSxFQUFFLEVBQUUsR0FBRyxJQUFJLEVBQUUsQ0FBQyxDQUFDO0lBQzFELENBQUM7SUFFTSxLQUFLLENBQUMsaUJBQWlCLENBQUMsVUFBa0I7UUFDL0MsTUFBTSxJQUFJLENBQUMsS0FBSyxDQUFDLFNBQVMsQ0FBQyxVQUFVLENBQUMsQ0FBQztJQUN6QyxDQUFDO0lBRU0sS0FBSyxDQUFDLEtBQUs7UUFDaEIsTUFBTSxJQUFJLENBQUMsRUFBRSxDQUFDLEtBQUssRUFBRSxDQUFDO0lBQ3hCLENBQUM7SUFDRDs7T0FFRztJQUNJLEtBQUssQ0FBQyxJQUFJO1FBQ2YsbUNBQW1DO1FBQ25DLE1BQU0sSUFBSSxDQUFDLEtBQUssQ0FBQyxJQUFJLEVBQUUsQ0FBQztJQUMxQixDQUFDO0NBQ0YifQ==

package/dist_ts/certmanagers.d.ts

@@ -0,0 +1,42 @@
+import * as plugins from './smartacme.plugins.js';
+import type { ICertManager } from './interfaces/certmanager.js';
+import { SmartacmeCert } from './smartacme.classes.cert.js';
+/**
+ * In-memory certificate manager for mongoless mode.
+ * Stores certificates in memory only and does not connect to MongoDB.
+ */
+export declare class MemoryCertManager implements ICertManager {
+    interestMap: plugins.lik.InterestMap<string, SmartacmeCert>;
+    private certs;
+    constructor();
+    init(): Promise<void>;
+    retrieveCertificate(domainName: string): Promise<SmartacmeCert | null>;
+    storeCertificate(cert: SmartacmeCert): Promise<void>;
+    deleteCertificate(domainName: string): Promise<void>;
+    close(): Promise<void>;
+    /**
+     * Wipe all certificates from the in-memory store (for testing)
+     */
+    wipe(): Promise<void>;
+}
+/**
+ * MongoDB-backed certificate manager using EasyStore from smartdata.
+ */
+export declare class MongoCertManager implements ICertManager {
+    interestMap: plugins.lik.InterestMap<string, SmartacmeCert>;
+    private db;
+    private store;
+    /**
+     * @param mongoDescriptor MongoDB connection settings
+     */
+    constructor(mongoDescriptor: plugins.smartdata.IMongoDescriptor);
+    init(): Promise<void>;
+    retrieveCertificate(domainName: string): Promise<SmartacmeCert | null>;
+    storeCertificate(cert: SmartacmeCert): Promise<void>;
+    deleteCertificate(domainName: string): Promise<void>;
+    close(): Promise<void>;
+    /**
+     * Wipe all certificates from the persistent store (for integration testing)
+     */
+    wipe(): Promise<void>;
+}

package/dist_ts/certmanagers.js

@@ -0,0 +1,86 @@
+import * as plugins from './smartacme.plugins.js';
+import { SmartacmeCert } from './smartacme.classes.cert.js';
+/**
+ * In-memory certificate manager for mongoless mode.
+ * Stores certificates in memory only and does not connect to MongoDB.
+ */
+export class MemoryCertManager {
+    constructor() {
+        this.certs = new Map();
+        this.interestMap = new plugins.lik.InterestMap((domain) => domain);
+    }
+    async init() {
+        // no-op for in-memory store
+    }
+    async retrieveCertificate(domainName) {
+        return this.certs.get(domainName) ?? null;
+    }
+    async storeCertificate(cert) {
+        this.certs.set(cert.domainName, cert);
+        const interest = this.interestMap.findInterest(cert.domainName);
+        if (interest) {
+            interest.fullfillInterest(cert);
+            interest.markLost();
+        }
+    }
+    async deleteCertificate(domainName) {
+        this.certs.delete(domainName);
+    }
+    async close() {
+        // no-op
+    }
+    /**
+     * Wipe all certificates from the in-memory store (for testing)
+     */
+    async wipe() {
+        this.certs.clear();
+        // reset interest map
+        this.interestMap = new plugins.lik.InterestMap((domain) => domain);
+    }
+}
+/**
+ * MongoDB-backed certificate manager using EasyStore from smartdata.
+ */
+export class MongoCertManager {
+    /**
+     * @param mongoDescriptor MongoDB connection settings
+     */
+    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);
+        this.interestMap = new plugins.lik.InterestMap((domain) => domain);
+    }
+    async init() {
+        await this.db.init();
+    }
+    async retrieveCertificate(domainName) {
+        const data = await this.store.readKey(domainName);
+        return data ? new SmartacmeCert(data) : null;
+    }
+    async storeCertificate(cert) {
+        // write plain object for persistence
+        await this.store.writeKey(cert.domainName, { ...cert });
+        const interest = this.interestMap.findInterest(cert.domainName);
+        if (interest) {
+            interest.fullfillInterest(cert);
+            interest.markLost();
+        }
+    }
+    async deleteCertificate(domainName) {
+        await this.store.deleteKey(domainName);
+    }
+    async close() {
+        await this.db.close();
+    }
+    /**
+     * Wipe all certificates from the persistent store (for integration testing)
+     */
+    async wipe() {
+        // clear all keys in the easy store
+        await this.store.wipe();
+        // reset interest map
+        this.interestMap = new plugins.lik.InterestMap((domain) => domain);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/handlers/Dns01Handler.js

@@ -13,8 +13,6 @@ export class Dns01Handler {
     async prepare(ch) {
         // set DNS TXT record
         await this.cf.convenience.acmeSetDnsChallenge(ch);
-        // wait for DNS propagation
-        await this.smartdns.checkUntilAvailable(ch.hostName, 'TXT', ch.challenge, 100, 5000);
     }
     async cleanup(ch) {
         // remove DNS TXT record
@@ -24,4 +22,4 @@ export class Dns01Handler {
         return this.cf.convenience.isDomainSupported(domainArg);
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRG5zMDFIYW5kbGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vdHMvaGFuZGxlcnMvRG5zMDFIYW5kbGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0seUJBQXlCLENBQUM7QUFHbkQ7O0dBRUc7QUFDSCxNQUFNLE9BQU8sWUFBWTtJQUl2QixZQUNFLHFCQUFxRSxFQUNyRSxnQkFBa0Q7UUFFbEQsSUFBSSxDQUFDLEVBQUUsR0FBRyxxQkFBcUIsQ0FBQztRQUNoQyxJQUFJLENBQUMsUUFBUSxHQUFHLGdCQUFnQixJQUFJLElBQUksT0FBTyxDQUFDLGNBQWMsQ0FBQyxRQUFRLENBQUMsRUFBRSxDQUFDLENBQUM7SUFDOUUsQ0FBQztJQUVNLGlCQUFpQjtRQUN0QixPQUFPLENBQUMsUUFBUSxDQUFDLENBQUM7SUFDcEIsQ0FBQztJQUVNLEtBQUssQ0FBQyxPQUFPLENBQUMsRUFBeUM7UUFDNUQscUJBQXFCO1FBQ3JCLE1BQU0sSUFBSSxDQUFDLEVBQUUsQ0FBQyxXQUFXLENBQUMsbUJBQW1CLENBQUMsRUFBRSxDQUFDLENBQUM7UUFDbEQsMkJBQTJCO1FBQzNCLE1BQU0sSUFBSSxDQUFDLFFBQVEsQ0FBQyxtQkFBbUIsQ0FDckMsRUFBRSxDQUFDLFFBQVEsRUFDWCxLQUFLLEVBQ0wsRUFBRSxDQUFDLFNBQVMsRUFDWixHQUFHLEVBQ0gsSUFBSSxDQUNMLENBQUM7SUFDSixDQUFDO0lBRU0sS0FBSyxDQUFDLE9BQU8sQ0FBQyxFQUF5QztRQUM1RCx3QkFBd0I7UUFDeEIsTUFBTSxJQUFJLENBQUMsRUFBRSxDQUFDLFdBQVcsQ0FBQyxzQkFBc0IsQ0FBQyxFQUFFLENBQUMsQ0FBQztJQUN2RCxDQUFDO0lBRU0sS0FBSyxDQUFDLDRCQUE0QixDQUFDLFNBQWlCO1FBQ3pELE9BQU8sSUFBSSxDQUFDLEVBQUUsQ0FBQyxXQUFXLENBQUMsaUJBQWlCLENBQUMsU0FBUyxDQUFDLENBQUM7SUFDMUQsQ0FBQztDQUNGIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRG5zMDFIYW5kbGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vdHMvaGFuZGxlcnMvRG5zMDFIYW5kbGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0seUJBQXlCLENBQUM7QUFHbkQ7O0dBRUc7QUFDSCxNQUFNLE9BQU8sWUFBWTtJQUl2QixZQUNFLHFCQUFxRSxFQUNyRSxnQkFBa0Q7UUFFbEQsSUFBSSxDQUFDLEVBQUUsR0FBRyxxQkFBcUIsQ0FBQztRQUNoQyxJQUFJLENBQUMsUUFBUSxHQUFHLGdCQUFnQixJQUFJLElBQUksT0FBTyxDQUFDLGNBQWMsQ0FBQyxRQUFRLENBQUMsRUFBRSxDQUFDLENBQUM7SUFDOUUsQ0FBQztJQUVNLGlCQUFpQjtRQUN0QixPQUFPLENBQUMsUUFBUSxDQUFDLENBQUM7SUFDcEIsQ0FBQztJQUVNLEtBQUssQ0FBQyxPQUFPLENBQUMsRUFBeUM7UUFDNUQscUJBQXFCO1FBQ3JCLE1BQU0sSUFBSSxDQUFDLEVBQUUsQ0FBQyxXQUFXLENBQUMsbUJBQW1CLENBQUMsRUFBRSxDQUFDLENBQUM7SUFDcEQsQ0FBQztJQUVNLEtBQUssQ0FBQyxPQUFPLENBQUMsRUFBeUM7UUFDNUQsd0JBQXdCO1FBQ3hCLE1BQU0sSUFBSSxDQUFDLEVBQUUsQ0FBQyxXQUFXLENBQUMsc0JBQXNCLENBQUMsRUFBRSxDQUFDLENBQUM7SUFDdkQsQ0FBQztJQUVNLEtBQUssQ0FBQyw0QkFBNEIsQ0FBQyxTQUFpQjtRQUN6RCxPQUFPLElBQUksQ0FBQyxFQUFFLENBQUMsV0FBVyxDQUFDLGlCQUFpQixDQUFDLFNBQVMsQ0FBQyxDQUFDO0lBQzFELENBQUM7Q0FDRiJ9

package/dist_ts/handlers/Http01Handler.d.ts

@@ -3,20 +3,20 @@ import type { IChallengeHandler } from './IChallengeHandler.js';
  * HTTP-01 ACME challenge handler using file-system webroot.
  * Writes and removes the challenge file under <webroot>/.well-known/acme-challenge/.
  */
-export interface Http01HandlerOptions {
+export interface Http01WebrootOptions {
     /**
      * Directory that serves HTTP requests for /.well-known/acme-challenge
      */
     webroot: string;
 }
-export declare class Http01Handler implements IChallengeHandler<{
+export declare class Http01Webroot implements IChallengeHandler<{
     type: string;
     token: string;
     keyAuthorization: string;
     webPath: string;
 }> {
     private webroot;
-    constructor(options: Http01HandlerOptions);
+    constructor(options: Http01WebrootOptions);
     getSupportedTypes(): string[];
     prepare(ch: {
         token: string;

package/dist_ts/handlers/Http01Handler.js

@@ -1,6 +1,6 @@
 import { promises as fs } from 'fs';
 import * as path from 'path';
-export class Http01Handler {
+export class Http01Webroot {
     constructor(options) {
         this.webroot = options.webroot;
     }

package/dist_ts/handlers/Http01MemoryHandler.d.ts

@@ -0,0 +1,26 @@
+import type { IChallengeHandler } from './IChallengeHandler.js';
+/**
+ * HTTP-01 ACME challenge handler using in-memory storage.
+ * Stores challenge tokens and key authorizations in memory
+ * and serves them via handleRequest for arbitrary HTTP servers.
+ */
+export interface Http01MemoryHandlerChallenge {
+    type: string;
+    token: string;
+    keyAuthorization: string;
+    webPath: string;
+}
+export declare class Http01MemoryHandler implements IChallengeHandler<Http01MemoryHandlerChallenge> {
+    private store;
+    getSupportedTypes(): string[];
+    prepare(ch: Http01MemoryHandlerChallenge): Promise<void>;
+    verify(_ch: Http01MemoryHandlerChallenge): Promise<void>;
+    cleanup(ch: Http01MemoryHandlerChallenge): Promise<void>;
+    /**
+     * HTTP request handler for serving ACME HTTP-01 challenges.
+     * @param req HTTP request object (should have url property)
+     * @param res HTTP response object
+     * @param next Optional next() callback for Express-style fallthrough
+     */
+    handleRequest(req: any, res: any, next?: () => void): void;
+}

package/dist_ts/handlers/Http01MemoryHandler.js

@@ -0,0 +1,51 @@
+export class Http01MemoryHandler {
+    constructor() {
+        this.store = new Map();
+    }
+    getSupportedTypes() {
+        return ['http-01'];
+    }
+    async prepare(ch) {
+        this.store.set(ch.token, ch.keyAuthorization);
+    }
+    async verify(_ch) {
+        // No-op
+        return;
+    }
+    async cleanup(ch) {
+        this.store.delete(ch.token);
+    }
+    /**
+     * HTTP request handler for serving ACME HTTP-01 challenges.
+     * @param req HTTP request object (should have url property)
+     * @param res HTTP response object
+     * @param next Optional next() callback for Express-style fallthrough
+     */
+    handleRequest(req, res, next) {
+        const url = req.url || '';
+        const prefix = '/.well-known/acme-challenge/';
+        if (!url.startsWith(prefix)) {
+            if (next) {
+                return next();
+            }
+            res.statusCode = 404;
+            return res.end();
+        }
+        const token = url.slice(prefix.length);
+        const keyAuth = this.store.get(token);
+        if (keyAuth !== undefined) {
+            if (typeof res.status === 'function' && typeof res.send === 'function') {
+                return res.status(200).send(keyAuth);
+            }
+            res.statusCode = 200;
+            res.setHeader('content-type', 'text/plain');
+            return res.end(keyAuth);
+        }
+        if (next) {
+            return next();
+        }
+        res.statusCode = 404;
+        return res.end();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/handlers/index.d.ts

@@ -1,3 +1,4 @@
 export type { IChallengeHandler } from './IChallengeHandler.js';
 export { Dns01Handler } from './Dns01Handler.js';
-export { Http01Handler } from './Http01Handler.js';
+export { Http01Webroot } from './Http01Handler.js';
+export { Http01MemoryHandler } from './Http01MemoryHandler.js';

package/dist_ts/handlers/index.js

@@ -1,4 +1,5 @@
 // Removed legacy handler adapter
 export { Dns01Handler } from './Dns01Handler.js';
-export { Http01Handler } from './Http01Handler.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9oYW5kbGVycy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxpQ0FBaUM7QUFDakMsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBQ2pELE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQyJ9
+export { Http01Webroot } from './Http01Handler.js';
+export { Http01MemoryHandler } from './Http01MemoryHandler.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9oYW5kbGVycy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxpQ0FBaUM7QUFDakMsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBQ2pELE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUNuRCxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQyJ9

package/dist_ts/index.d.ts

@@ -1,2 +1,4 @@
 export * from './smartacme.classes.smartacme.js';
 export { SmartacmeCert as Cert } from './smartacme.classes.cert.js';
+export type { ICertManager } from './interfaces/certmanager.js';
+export { MemoryCertManager, MongoCertManager } from './certmanagers/index.js';

package/dist_ts/index.js

@@ -1,3 +1,4 @@
 export * from './smartacme.classes.smartacme.js';
 export { SmartacmeCert as Cert } from './smartacme.classes.cert.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGtDQUFrQyxDQUFDO0FBQ2pELE9BQU8sRUFBRSxhQUFhLElBQUksSUFBSSxFQUFFLE1BQU0sNkJBQTZCLENBQUMifQ==
+export { MemoryCertManager, MongoCertManager } from './certmanagers/index.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGtDQUFrQyxDQUFDO0FBQ2pELE9BQU8sRUFBRSxhQUFhLElBQUksSUFBSSxFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFFcEUsT0FBTyxFQUFFLGlCQUFpQixFQUFFLGdCQUFnQixFQUFFLE1BQU0seUJBQXlCLENBQUMifQ==

package/dist_ts/interfaces/certmanager.d.ts

@@ -0,0 +1,33 @@
+import type { SmartacmeCert } from '../smartacme.classes.cert.js';
+/**
+ * Interface for certificate storage managers.
+ * Users can implement this to provide custom persistence (in-memory,
+ * file-based, Redis, etc.).
+ */
+export interface ICertManager {
+    /**
+     * Initialize the store (e.g., connect to database).
+     */
+    init(): Promise<void>;
+    /**
+     * Retrieve a certificate record by domain name.
+     * Returns null if none found.
+     */
+    retrieveCertificate(domainName: string): Promise<SmartacmeCert | null>;
+    /**
+     * Store a certificate record. Fulfills any pending interests.
+     */
+    storeCertificate(cert: SmartacmeCert): Promise<void>;
+    /**
+     * Delete a certificate record by domain name.
+     */
+    deleteCertificate(domainName: string): Promise<void>;
+    /**
+     * Close the store (e.g., disconnect database).
+     */
+    close(): Promise<void>;
+    /**
+     * Optional: wipe all stored certificates (e.g., for integration testing)
+     */
+    wipe(): Promise<void>;
+}

package/dist_ts/interfaces/certmanager.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2VydG1hbmFnZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9pbnRlcmZhY2VzL2NlcnRtYW5hZ2VyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ==

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

@@ -1,5 +1,7 @@
-import * as plugins from './smartacme.plugins.js';
-export declare class SmartacmeCert extends plugins.smartdata.SmartDataDbDoc<SmartacmeCert, plugins.tsclass.network.ICert> implements plugins.tsclass.network.ICert {
+/**
+ * Plain certificate record.
+ */
+export declare class SmartacmeCert {
     id: string;
     domainName: string;
     created: number;
@@ -7,8 +9,13 @@ export declare class SmartacmeCert extends plugins.smartdata.SmartDataDbDoc<Smar
     publicKey: string;
     csr: string;
     validUntil: number;
+    constructor(data?: Partial<SmartacmeCert>);
+    /**
+     * Check if certificate is still valid.
+     */
     isStillValid(): boolean;
+    /**
+     * Check if certificate needs renewal (e.g., expires in <10 days).
+     */
     shouldBeRenewed(): boolean;
-    update(certDataArg: plugins.tsclass.network.ICert): void;
-    constructor(optionsArg: plugins.tsclass.network.ICert);
 }

package/dist_ts/smartacme.classes.cert.js

@@ -1,74 +1,29 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
 import * as plugins from './smartacme.plugins.js';
-import * as interfaces from './interfaces/index.js';
-import { SmartacmeCertManager } from './smartacme.classes.certmanager.js';
-import { Collection, svDb, unI } from '@push.rocks/smartdata';
-let SmartacmeCert = class SmartacmeCert extends plugins.smartdata.SmartDataDbDoc {
+/**
+ * Plain certificate record.
+ */
+export class SmartacmeCert {
+    constructor(data = {}) {
+        this.id = data.id || '';
+        this.domainName = data.domainName || '';
+        this.created = data.created || Date.now();
+        this.privateKey = data.privateKey || '';
+        this.publicKey = data.publicKey || '';
+        this.csr = data.csr || '';
+        this.validUntil = data.validUntil || 0;
+    }
+    /**
+     * Check if certificate is still valid.
+     */
     isStillValid() {
         return this.validUntil >= Date.now();
     }
+    /**
+     * Check if certificate needs renewal (e.g., expires in <10 days).
+     */
     shouldBeRenewed() {
-        const shouldBeValidAtLeastUntil = Date.now() +
-            plugins.smarttime.getMilliSecondsFromUnits({
-                days: 10,
-            });
-        return !(this.validUntil >= shouldBeValidAtLeastUntil);
-    }
-    update(certDataArg) {
-        Object.keys(certDataArg).forEach((key) => {
-            this[key] = certDataArg[key];
-        });
-    }
-    constructor(optionsArg) {
-        super();
-        if (optionsArg) {
-            Object.keys(optionsArg).forEach((key) => {
-                this[key] = optionsArg[key];
-            });
-        }
+        const threshold = Date.now() + plugins.smarttime.getMilliSecondsFromUnits({ days: 10 });
+        return this.validUntil < threshold;
     }
-};
-__decorate([
-    unI(),
-    __metadata("design:type", String)
-], SmartacmeCert.prototype, "id", void 0);
-__decorate([
-    svDb(),
-    __metadata("design:type", String)
-], SmartacmeCert.prototype, "domainName", void 0);
-__decorate([
-    svDb(),
-    __metadata("design:type", Number)
-], SmartacmeCert.prototype, "created", void 0);
-__decorate([
-    svDb(),
-    __metadata("design:type", String)
-], SmartacmeCert.prototype, "privateKey", void 0);
-__decorate([
-    svDb(),
-    __metadata("design:type", String)
-], SmartacmeCert.prototype, "publicKey", void 0);
-__decorate([
-    svDb(),
-    __metadata("design:type", String)
-], SmartacmeCert.prototype, "csr", void 0);
-__decorate([
-    svDb(),
-    __metadata("design:type", Number)
-], SmartacmeCert.prototype, "validUntil", void 0);
-SmartacmeCert = __decorate([
-    plugins.smartdata.Collection(() => {
-        return SmartacmeCertManager.activeDB;
-    }),
-    __metadata("design:paramtypes", [Object])
-], SmartacmeCert);
-export { SmartacmeCert };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRhY21lLmNsYXNzZXMuY2VydC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0YWNtZS5jbGFzc2VzLmNlcnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7O0FBQUEsT0FBTyxLQUFLLE9BQU8sTUFBTSx3QkFBd0IsQ0FBQztBQUVsRCxPQUFPLEtBQUssVUFBVSxNQUFNLHVCQUF1QixDQUFDO0FBRXBELE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLG9DQUFvQyxDQUFDO0FBRTFFLE9BQU8sRUFBRSxVQUFVLEVBQUUsSUFBSSxFQUFFLEdBQUcsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBS3ZELElBQU0sYUFBYSxHQUFuQixNQUFNLGFBQ1gsU0FBUSxPQUFPLENBQUMsU0FBUyxDQUFDLGNBQTREO0lBd0IvRSxZQUFZO1FBQ2pCLE9BQU8sSUFBSSxDQUFDLFVBQVUsSUFBSSxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUM7SUFDdkMsQ0FBQztJQUVNLGVBQWU7UUFDcEIsTUFBTSx5QkFBeUIsR0FDN0IsSUFBSSxDQUFDLEdBQUcsRUFBRTtZQUNWLE9BQU8sQ0FBQyxTQUFTLENBQUMsd0JBQXdCLENBQUM7Z0JBQ3pDLElBQUksRUFBRSxFQUFFO2FBQ1QsQ0FBQyxDQUFDO1FBQ0wsT0FBTyxDQUFDLENBQUMsSUFBSSxDQUFDLFVBQVUsSUFBSSx5QkFBeUIsQ0FBQyxDQUFDO0lBQ3pELENBQUM7SUFFTSxNQUFNLENBQUMsV0FBMEM7UUFDdEQsTUFBTSxDQUFDLElBQUksQ0FBQyxXQUFXLENBQUMsQ0FBQyxPQUFPLENBQUMsQ0FBQyxHQUFHLEVBQUUsRUFBRTtZQUN2QyxJQUFJLENBQUMsR0FBRyxDQUFDLEdBQUcsV0FBVyxDQUFDLEdBQUcsQ0FBQyxDQUFDO1FBQy9CLENBQUMsQ0FBQyxDQUFDO0lBQ0wsQ0FBQztJQUVELFlBQVksVUFBeUM7UUFDbkQsS0FBSyxFQUFFLENBQUM7UUFDUixJQUFJLFVBQVUsRUFBRSxDQUFDO1lBQ2YsTUFBTSxDQUFDLElBQUksQ0FBQyxVQUFVLENBQUMsQ0FBQyxPQUFPLENBQUMsQ0FBQyxHQUFHLEVBQUUsRUFBRTtnQkFDdEMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxHQUFHLFVBQVUsQ0FBQyxHQUFHLENBQUMsQ0FBQztZQUM5QixDQUFDLENBQUMsQ0FBQztRQUNMLENBQUM7SUFDSCxDQUFDO0NBQ0YsQ0FBQTtBQS9DUTtJQUROLEdBQUcsRUFBRTs7eUNBQ1k7QUFHWDtJQUROLElBQUksRUFBRTs7aURBQ21CO0FBR25CO0lBRE4sSUFBSSxFQUFFOzs4Q0FDZ0I7QUFHaEI7SUFETixJQUFJLEVBQUU7O2lEQUNtQjtBQUduQjtJQUROLElBQUksRUFBRTs7Z0RBQ2tCO0FBR2xCO0lBRE4sSUFBSSxFQUFFOzswQ0FDWTtBQUdaO0lBRE4sSUFBSSxFQUFFOztpREFDbUI7QUF2QmYsYUFBYTtJQUh6QixPQUFPLENBQUMsU0FBUyxDQUFDLFVBQVUsQ0FBQyxHQUFHLEVBQUU7UUFDakMsT0FBTyxvQkFBb0IsQ0FBQyxRQUFRLENBQUM7SUFDdkMsQ0FBQyxDQUFDOztHQUNXLGFBQWEsQ0FvRHpCIn0=
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRhY21lLmNsYXNzZXMuY2VydC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0YWNtZS5jbGFzc2VzLmNlcnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLE9BQU8sTUFBTSx3QkFBd0IsQ0FBQztBQUVsRDs7R0FFRztBQUNILE1BQU0sT0FBTyxhQUFhO0lBU3hCLFlBQVksT0FBK0IsRUFBRTtRQUMzQyxJQUFJLENBQUMsRUFBRSxHQUFHLElBQUksQ0FBQyxFQUFFLElBQUksRUFBRSxDQUFDO1FBQ3hCLElBQUksQ0FBQyxVQUFVLEdBQUcsSUFBSSxDQUFDLFVBQVUsSUFBSSxFQUFFLENBQUM7UUFDeEMsSUFBSSxDQUFDLE9BQU8sR0FBRyxJQUFJLENBQUMsT0FBTyxJQUFJLElBQUksQ0FBQyxHQUFHLEVBQUUsQ0FBQztRQUMxQyxJQUFJLENBQUMsVUFBVSxHQUFHLElBQUksQ0FBQyxVQUFVLElBQUksRUFBRSxDQUFDO1FBQ3hDLElBQUksQ0FBQyxTQUFTLEdBQUcsSUFBSSxDQUFDLFNBQVMsSUFBSSxFQUFFLENBQUM7UUFDdEMsSUFBSSxDQUFDLEdBQUcsR0FBRyxJQUFJLENBQUMsR0FBRyxJQUFJLEVBQUUsQ0FBQztRQUMxQixJQUFJLENBQUMsVUFBVSxHQUFHLElBQUksQ0FBQyxVQUFVLElBQUksQ0FBQyxDQUFDO0lBQ3pDLENBQUM7SUFFRDs7T0FFRztJQUNJLFlBQVk7UUFDakIsT0FBTyxJQUFJLENBQUMsVUFBVSxJQUFJLElBQUksQ0FBQyxHQUFHLEVBQUUsQ0FBQztJQUN2QyxDQUFDO0lBRUQ7O09BRUc7SUFDSSxlQUFlO1FBQ3BCLE1BQU0sU0FBUyxHQUFHLElBQUksQ0FBQyxHQUFHLEVBQUUsR0FBRyxPQUFPLENBQUMsU0FBUyxDQUFDLHdCQUF3QixDQUFDLEVBQUUsSUFBSSxFQUFFLEVBQUUsRUFBRSxDQUFDLENBQUM7UUFDeEYsT0FBTyxJQUFJLENBQUMsVUFBVSxHQUFHLFNBQVMsQ0FBQztJQUNyQyxDQUFDO0NBQ0YifQ==

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

@@ -22,4 +22,22 @@ export declare class SmartacmeCertManager {
      */
     storeCertificate(optionsArg: plugins.tsclass.network.ICert): Promise<void>;
     deleteCertificate(certDomainNameArg: string): Promise<void>;
+    /**
+     * Close underlying MongoDB connection
+     */
+    close(): Promise<void>;
+}
+/**
+ * In-memory certificate manager for mongoless mode.
+ * Stores certificates in memory only and does not connect to MongoDB.
+ */
+export declare class MemoryCertManager {
+    interestMap: plugins.lik.InterestMap<string, SmartacmeCert>;
+    private certs;
+    constructor();
+    init(): Promise<void>;
+    retrieveCertificate(certDomainName: string): Promise<SmartacmeCert>;
+    storeCertificate(optionsArg: plugins.tsclass.network.ICert): Promise<void>;
+    deleteCertificate(certDomainName: string): Promise<void>;
+    close(): Promise<void>;
 }