@push.rocks/smartacme 9.5.0 → 9.7.0

package/dist_ts/classes.exact-certificate-issuer.js

@@ -0,0 +1,397 @@
+import * as plugins from './plugins.js';
+export function normalizeCertificateIdentifiers(input) {
+    if (!Array.isArray(input) || input.length < 1 || input.length > 100) {
+        throw new Error('Between one and 100 explicit DNS identifiers are required');
+    }
+    return [...new Set(Array.from(input, (value) => {
+            if (typeof value !== 'string' || value.length > 1024)
+                throw new Error('Invalid DNS identifier');
+            const trimmed = value.trim().toLowerCase().replace(/\.$/, '');
+            if (/[/\\:@?#%\s]/.test(trimmed))
+                throw new Error('Invalid DNS identifier');
+            const wildcard = trimmed.startsWith('*.');
+            const name = plugins.url.domainToASCII(wildcard ? trimmed.slice(2) : trimmed);
+            if (!name || plugins.net.isIP(name) !== 0 || name.length > 253 || name.split('.').length < 2
+                || name.split('.').some((label) => !/^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/.test(label))) {
+                throw new Error('Invalid DNS identifier');
+            }
+            return `${wildcard ? '*.' : ''}${name}`;
+        }))].sort();
+}
+/** Owns exact-name issuance and recovery; the embedding service supplies storage. */
+export class ExactCertificateIssuer {
+    constructor(options) {
+        this.options = options;
+    }
+    identity(request) {
+        if (typeof request.namespace !== 'string' || !/^[\x21-\x7e]{1,200}$/.test(request.namespace)) {
+            throw new Error('A nonempty printable isolation namespace of at most 200 characters is required');
+        }
+        const identifiers = normalizeCertificateIdentifiers(request.identifiers);
+        const binding = {
+            namespace: request.namespace,
+            identifiers,
+            directoryUrl: this.options.directoryUrl,
+            accountThumbprint: this.options.accountThumbprint,
+        };
+        return {
+            ...binding,
+            certificateKey: `exact-v1:${plugins.crypto.createHash('sha256').update(JSON.stringify(binding)).digest('hex')}`,
+        };
+    }
+    async status(request) {
+        const identity = this.identity(request);
+        const record = await this.options.store.getIssuance(identity.certificateKey);
+        if (record)
+            this.validateRecord(record, identity);
+        return record ? this.info(record) : null;
+    }
+    /** Validate the cache before taking any issuance or CA rate-limit slot. */
+    async cached(request) {
+        const identity = this.identity(request);
+        const certificate = await this.options.store.getCertificate(identity.certificateKey);
+        if (!certificate)
+            return null;
+        this.validateCertificate(certificate, identity);
+        const record = await this.options.store.getIssuance(identity.certificateKey);
+        if (record?.status !== 'ready' || certificate.id !== record.issuanceId
+            || Date.now() >= certificate.renewAfter || Date.now() >= certificate.validUntil)
+            return null;
+        this.validateRecord(record, identity);
+        return { status: 'ready', certificate, issuance: this.info(record) };
+    }
+    async run(request) {
+        this.options.signal.throwIfAborted();
+        const identity = this.identity(request);
+        let record = await this.options.store.getIssuance(identity.certificateKey);
+        const cached = await this.options.store.getCertificate(identity.certificateKey);
+        if (cached) {
+            this.validateCertificate(cached, identity);
+            if (record?.status === 'ready' && cached.id === record.issuanceId && Date.now() < cached.renewAfter) {
+                this.validateRecord(record, identity);
+                return { status: 'ready', certificate: cached, issuance: this.info(record) };
+            }
+        }
+        if (record?.status === 'ready' && !cached) {
+            this.validateRecord(record, identity);
+            return await this.advance(record, true);
+        }
+        if (!record || record.status === 'ready') {
+            const [privateKey, csr] = await plugins.acme.AcmeCrypto.createCsr({
+                commonName: identity.identifiers[0], altNames: identity.identifiers.slice(1),
+            });
+            const next = {
+                ...identity, issuanceId: plugins.crypto.randomUUID(), revision: (record?.revision ?? -1) + 1,
+                status: 'prepared', createdAt: Date.now(), updatedAt: Date.now(), privateKey, csr,
+                pendingChallenges: [],
+            };
+            this.options.signal.throwIfAborted();
+            if (!await this.options.store.compareAndSetIssuance(identity.certificateKey, record?.revision ?? null, next)) {
+                const current = await this.requiredRecord(identity.certificateKey);
+                return { status: 'pending', issuance: this.info(current) };
+            }
+            record = next;
+        }
+        this.validateRecord(record, identity);
+        return await this.advance(record, false);
+    }
+    async recover(request) {
+        if (!['recheck', 'retry-proven-unapplied', 'abandon'].includes(request.action)
+            || !Number.isSafeInteger(request.expectedRevision) || request.expectedRevision < 0
+            || typeof request.issuanceId !== 'string' || !request.issuanceId) {
+            throw new Error('Invalid issuance recovery request');
+        }
+        const identity = this.identity(request);
+        let record = await this.requiredRecord(identity.certificateKey);
+        this.validateRecord(record, identity);
+        if (record.issuanceId !== request.issuanceId || record.revision !== request.expectedRevision) {
+            throw new Error('Issuance recovery revision conflict');
+        }
+        if (request.action === 'abandon') {
+            if (record.status === 'ready')
+                throw new Error('A completed issuance cannot be abandoned');
+            record = await this.save(record, { status: 'abandoned_unverified' });
+            await this.cleanup(record);
+            return { status: 'pending', issuance: this.info(await this.requiredRecord(record.certificateKey)) };
+        }
+        if (record.status === 'abandoned_unverified') {
+            throw new Error('Abandoned issuance requires external resolution; new issuance remains blocked');
+        }
+        if (request.action === 'retry-proven-unapplied') {
+            // Only an acknowledged rejection of newOrder proves no order was created.
+            if (record.order || record.status !== 'failed' || record.errorCode !== 'rate_limited') {
+                throw new Error('The previous external effect is not proven unapplied');
+            }
+            if (record.retryAfter && record.retryAfter > Date.now()) {
+                return { status: 'pending', issuance: this.info(record) };
+            }
+            record = await this.save(record, { status: 'prepared', errorCode: undefined, retryAfter: undefined });
+            return await this.advance(record, false);
+        }
+        return await this.advance(record, true);
+    }
+    async advance(initial, recheckOnly) {
+        let record = initial;
+        this.options.signal.throwIfAborted();
+        if (record.status === 'abandoned_unverified' || record.status === 'failed') {
+            return { status: 'pending', issuance: this.info(record) };
+        }
+        if (record.status === 'creating' || (record.status === 'indeterminate' && !record.order)) {
+            record = await this.save(record, { status: 'indeterminate', errorCode: 'order_outcome_unknown' });
+            return { status: 'pending', issuance: this.info(record) };
+        }
+        if (record.status === 'prepared') {
+            if (recheckOnly)
+                return { status: 'pending', issuance: this.info(record) };
+            // Prove challenge support before creating an irreversible CA order.
+            await this.handler(record);
+            record = await this.save(record, { status: 'creating' });
+            let order;
+            try {
+                this.options.signal.throwIfAborted();
+                order = await this.options.client.createOrder({
+                    identifiers: record.identifiers.map((value) => ({ type: 'dns', value })),
+                });
+            }
+            catch (error) {
+                const rejected = error instanceof plugins.acme.AcmeError && error.isRateLimited;
+                record = await this.save(record, {
+                    status: rejected ? 'failed' : 'indeterminate',
+                    errorCode: rejected ? 'rate_limited' : 'order_outcome_unknown',
+                    retryAfter: rejected ? Date.now() + Math.max(error.retryAfter, 60) * 1000 : undefined,
+                });
+                return { status: 'pending', issuance: this.info(record) };
+            }
+            if (!order.url) {
+                record = await this.save(record, { status: 'indeterminate', errorCode: 'order_outcome_unknown' });
+                return { status: 'pending', issuance: this.info(record) };
+            }
+            record = await this.save(record, { order, status: 'authorizing' });
+        }
+        if (!record.order)
+            throw new Error('Issuance record has no acknowledged order');
+        const observed = await this.options.client.getOrder(record.order.url);
+        this.validateOrder(observed, record);
+        record = await this.save(record, { order: observed, errorCode: undefined });
+        if (observed.status === 'invalid' || observed.status === 'expired' || observed.status === 'revoked') {
+            record = await this.save(record, { status: 'failed', errorCode: 'order_invalid' });
+            await this.cleanup(record);
+            return { status: 'pending', issuance: this.info(await this.requiredRecord(record.certificateKey)) };
+        }
+        if (observed.status === 'valid')
+            return await this.finish(record);
+        if (recheckOnly) {
+            return { status: 'pending', issuance: this.info(record) };
+        }
+        if (record.status === 'finalizing' || record.status === 'indeterminate') {
+            // Acknowledged processing/ready observations do not prove a previous
+            // finalize request was unapplied. Never send a new CSR on uncertainty.
+            record = await this.save(record, { status: 'indeterminate', errorCode: 'order_outcome_unknown' });
+            return { status: 'pending', issuance: this.info(record) };
+        }
+        if (observed.status === 'pending') {
+            record = await this.authorize(record);
+            if (record.status === 'failed')
+                return { status: 'pending', issuance: this.info(record) };
+        }
+        const ready = await this.options.client.getOrder(record.order.url);
+        this.validateOrder(ready, record);
+        record = await this.save(record, { order: ready });
+        if (ready.status === 'valid')
+            return await this.finish(record);
+        if (ready.status !== 'ready') {
+            return { status: 'pending', issuance: this.info(record) };
+        }
+        record = await this.save(record, { status: 'finalizing' });
+        try {
+            this.options.signal.throwIfAborted();
+            await this.options.client.finalizeOrder(structuredClone(ready), record.csr);
+        }
+        catch {
+            // Preserve the acknowledged order and original key/CSR for safe recheck.
+            record = await this.save(record, { status: 'indeterminate', errorCode: 'order_outcome_unknown' });
+            return { status: 'pending', issuance: this.info(record) };
+        }
+        const finalized = await this.options.client.getOrder(ready.url);
+        this.validateOrder(finalized, record);
+        record = await this.save(record, { order: finalized });
+        return finalized.status === 'valid'
+            ? await this.finish(record)
+            : { status: 'pending', issuance: this.info(record) };
+    }
+    async authorize(initial) {
+        let record = initial;
+        const handler = await this.handler(record);
+        const authorizations = await this.options.client.getAuthorizations(record.order);
+        for (const authorization of authorizations) {
+            this.options.signal.throwIfAborted();
+            const identifier = `${authorization.wildcard ? '*.' : ''}${authorization.identifier.value}`;
+            if (authorization.identifier.type !== 'dns' || !record.identifiers.includes(identifier)) {
+                throw new Error('CA authorization is outside the requested identifiers');
+            }
+            if (authorization.status === 'valid')
+                continue;
+            if (authorization.status !== 'pending') {
+                return await this.save(record, { status: 'failed', errorCode: 'authorization_failed' });
+            }
+            const challenge = authorization.challenges.find((value) => value.type === 'dns-01');
+            if (!challenge)
+                throw new Error('The CA did not offer DNS-01');
+            const input = {
+                hostName: `_acme-challenge.${authorization.identifier.value}`,
+                challenge: this.options.client.getChallengeKeyAuthorization(challenge),
+            };
+            if (!record.pendingChallenges.some((value) => value.hostName === input.hostName && value.challenge === input.challenge)) {
+                record = await this.save(record, { pendingChallenges: [...record.pendingChallenges, input] });
+            }
+            try {
+                await handler.prepare(input, this.challengeContext(record));
+                if (handler.verify) {
+                    await handler.verify(input, this.challengeContext(record));
+                }
+                else {
+                    let visible = false;
+                    for (let attempt = 0; attempt < 100; attempt++) {
+                        this.options.signal.throwIfAborted();
+                        const records = await this.options.dns.getRecords(input.hostName, 'TXT', 0);
+                        if (records.some((value) => value.value === input.challenge)) {
+                            visible = true;
+                            break;
+                        }
+                        await plugins.timers.setTimeout(1000, undefined, { signal: this.options.signal });
+                    }
+                    if (!visible)
+                        throw new Error('DNS-01 propagation timed out');
+                }
+                await plugins.timers.setTimeout(this.options.dnsPropagationDelayMs, undefined, { signal: this.options.signal });
+                await this.options.client.completeChallenge(challenge);
+                await this.options.client.waitForValidStatus(challenge);
+            }
+            finally {
+                // Persist cleanup intent until cleanup actually succeeds, including
+                // failure during prepare, process shutdown, or certificate retrieval.
+                await handler.cleanup(input, this.challengeContext(record));
+                record = await this.save(record, {
+                    pendingChallenges: record.pendingChallenges.filter((value) => value.hostName !== input.hostName || value.challenge !== input.challenge),
+                });
+            }
+        }
+        return record;
+    }
+    async finish(initial) {
+        let record = initial;
+        if (!record.order?.certificate)
+            throw new Error('Completed order has no certificate URL');
+        const pem = await this.options.client.getCertificate(record.order);
+        const x509 = new plugins.crypto.X509Certificate(pem);
+        const validFrom = new Date(x509.validFrom).getTime();
+        const validUntil = new Date(x509.validTo).getTime();
+        const certificate = {
+            ...this.identity(record), id: record.issuanceId, created: Date.now(),
+            privateKey: record.privateKey, csr: record.csr, publicKey: pem, validFrom, validUntil,
+            renewAfter: validUntil - Math.min(10 * 86400000, (validUntil - validFrom) / 3),
+        };
+        try {
+            this.validateCertificate(certificate, record);
+            if (validUntil <= Date.now())
+                throw new Error('CA returned an expired certificate');
+        }
+        catch {
+            record = await this.save(record, { status: 'failed', errorCode: 'certificate_invalid' });
+            return { status: 'pending', issuance: this.info(record) };
+        }
+        await this.cleanup(record);
+        record = await this.requiredRecord(record.certificateKey);
+        if (record.status === 'abandoned_unverified') {
+            return { status: 'pending', issuance: this.info(record) };
+        }
+        await this.options.store.storeCertificate(certificate);
+        record = await this.save(record, { status: 'ready', errorCode: undefined });
+        return { status: 'ready', certificate, issuance: this.info(record) };
+    }
+    async handler(record) {
+        const handler = this.options.handlers.find((value) => value.getSupportedTypes().includes('dns-01'));
+        if (!handler)
+            throw new Error('Exact issuance requires DNS-01');
+        for (const identifier of record.identifiers) {
+            if (!await handler.checkWetherDomainIsSupported(identifier.replace(/^\*\./, ''))) {
+                throw new Error('DNS-01 ownership is unavailable for a requested identifier');
+            }
+        }
+        return handler;
+    }
+    async cleanup(initial) {
+        let record = initial;
+        if (!record.pendingChallenges.length)
+            return;
+        const handler = this.options.handlers.find((value) => value.getSupportedTypes().includes('dns-01'));
+        if (!handler)
+            throw new Error('DNS-01 cleanup handler is unavailable');
+        for (const input of [...record.pendingChallenges]) {
+            await handler.cleanup(input, this.challengeContext(record));
+            record = await this.save(record, {
+                pendingChallenges: record.pendingChallenges.filter((value) => value.hostName !== input.hostName || value.challenge !== input.challenge),
+            });
+        }
+    }
+    challengeContext(record) {
+        return { operationId: plugins.crypto.createHash('sha256')
+                .update(JSON.stringify(['smartacme-exact-challenge-v1', record.certificateKey, record.issuanceId])).digest('hex') };
+    }
+    validateRecord(record, identity) {
+        if (record.certificateKey !== identity.certificateKey
+            || this.identity(record).certificateKey !== identity.certificateKey
+            || record.accountThumbprint !== identity.accountThumbprint || record.directoryUrl !== identity.directoryUrl) {
+            throw new Error('Issuance storage identity mismatch');
+        }
+    }
+    validateOrder(order, record) {
+        if (!order.url || order.identifiers.some((value) => value.type !== 'dns')
+            || JSON.stringify(normalizeCertificateIdentifiers(order.identifiers.map((value) => value.value))) !== JSON.stringify(record.identifiers)) {
+            throw new Error('CA order identifiers do not match the certificate request');
+        }
+    }
+    validateCertificate(certificate, identity) {
+        if (certificate.certificateKey !== identity.certificateKey
+            || this.identity(certificate).certificateKey !== identity.certificateKey
+            || certificate.accountThumbprint !== identity.accountThumbprint || certificate.directoryUrl !== identity.directoryUrl) {
+            throw new Error('Certificate storage identity mismatch');
+        }
+        const parsed = new plugins.x509.X509Certificate(certificate.publicKey);
+        const names = parsed.getExtension(plugins.x509.SubjectAlternativeNameExtension)?.names.toJSON();
+        if (!names || names.some((value) => value.type !== 'dns')
+            || JSON.stringify(normalizeCertificateIdentifiers(names.map((value) => value.value))) !== JSON.stringify(identity.identifiers)) {
+            throw new Error('Certificate identifiers exceed or differ from the requested scope');
+        }
+        const x509 = new plugins.crypto.X509Certificate(certificate.publicKey);
+        if (x509.ca || !x509.checkPrivateKey(plugins.crypto.createPrivateKey(certificate.privateKey))
+            || new Date(x509.validFrom).getTime() !== certificate.validFrom
+            || new Date(x509.validTo).getTime() !== certificate.validUntil
+            || certificate.validFrom > Date.now() + 300000
+            || !Number.isFinite(certificate.renewAfter) || certificate.renewAfter >= certificate.validUntil) {
+            throw new Error('Invalid certificate key, lifetime, or constraints');
+        }
+    }
+    info(record) {
+        return {
+            certificateKey: record.certificateKey, issuanceId: record.issuanceId,
+            identifiers: [...record.identifiers], status: record.status, revision: record.revision,
+            createdAt: record.createdAt, updatedAt: record.updatedAt,
+            errorCode: record.errorCode, retryAfter: record.retryAfter,
+        };
+    }
+    async requiredRecord(key) {
+        const record = await this.options.store.getIssuance(key);
+        if (!record)
+            throw new Error('Issuance recovery record is missing');
+        return record;
+    }
+    async save(record, patch) {
+        const next = { ...record, ...patch, revision: record.revision + 1, updatedAt: Date.now() };
+        if (!await this.options.store.compareAndSetIssuance(record.certificateKey, record.revision, next)) {
+            throw new Error('Issuance changed concurrently; reload its durable state before proceeding');
+        }
+        return next;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.exact-certificate-issuer.js","sourceRoot":"","sources":["../../ts/classes.exact-certificate-issuer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,cAAc,CAAC;AAYxC,MAAM,UAAU,+BAA+B,CAAC,KAAwB;IACtE,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,IAAI,KAAK,CAAC,MAAM,GAAG,GAAG,EAAE,CAAC;QACpE,MAAM,IAAI,KAAK,CAAC,2DAA2D,CAAC,CAAC;IAC/E,CAAC;IACD,OAAO,CAAC,GAAG,IAAI,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,EAAE;YAC7C,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,CAAC,MAAM,GAAG,IAAI;gBAAE,MAAM,IAAI,KAAK,CAAC,wBAAwB,CAAC,CAAC;YAChG,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;YAC9D,IAAI,cAAc,CAAC,IAAI,CAAC,OAAO,CAAC;gBAAE,MAAM,IAAI,KAAK,CAAC,wBAAwB,CAAC,CAAC;YAC5E,MAAM,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;YAC1C,MAAM,IAAI,GAAG,OAAO,CAAC,GAAG,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;YAC9E,IAAI,CAAC,IAAI,IAAI,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,IAAI,CAAC,MAAM,GAAG,GAAG,IAAI,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,MAAM,GAAG,CAAC;mBACvF,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,wCAAwC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC;gBAC5F,MAAM,IAAI,KAAK,CAAC,wBAAwB,CAAC,CAAC;YAC5C,CAAC;YACD,OAAO,GAAG,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,GAAG,IAAI,EAAE,CAAC;QAC1C,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;AACd,CAAC;AAcD,qFAAqF;AACrF,MAAM,OAAO,sBAAsB;IACjC,YAAoB,OAAuC;QAAvC,YAAO,GAAP,OAAO,CAAgC;IAAG,CAAC;IAExD,QAAQ,CAAC,OAAiC;QAC/C,IAAI,OAAO,OAAO,CAAC,SAAS,KAAK,QAAQ,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC;YAC7F,MAAM,IAAI,KAAK,CAAC,gFAAgF,CAAC,CAAC;QACpG,CAAC;QACD,MAAM,WAAW,GAAG,+BAA+B,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;QACzE,MAAM,OAAO,GAAG;YACd,SAAS,EAAE,OAAO,CAAC,SAAS;YAC5B,WAAW;YACX,YAAY,EAAE,IAAI,CAAC,OAAO,CAAC,YAAY;YACvC,iBAAiB,EAAE,IAAI,CAAC,OAAO,CAAC,iBAAiB;SAClD,CAAC;QACF,OAAO;YACL,GAAG,OAAO;YACV,cAAc,EAAE,YAAY,OAAO,CAAC,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE;SAChH,CAAC;IACJ,CAAC;IAEM,KAAK,CAAC,MAAM,CAAC,OAAiC;QACnD,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;QACxC,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,WAAW,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC;QAC7E,IAAI,MAAM;YAAE,IAAI,CAAC,cAAc,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;QAClD,OAAO,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IAC3C,CAAC;IAED,2EAA2E;IACpE,KAAK,CAAC,MAAM,CAAC,OAAiC;QACnD,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;QACxC,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,cAAc,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC;QACrF,IAAI,CAAC,WAAW;YAAE,OAAO,IAAI,CAAC;QAC9B,IAAI,CAAC,mBAAmB,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAC;QAChD,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,WAAW,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC;QAC7E,IAAI,MAAM,EAAE,MAAM,KAAK,OAAO,IAAI,WAAW,CAAC,EAAE,KAAK,MAAM,CAAC,UAAU;eACjE,IAAI,CAAC,GAAG,EAAE,IAAI,WAAW,CAAC,UAAU,IAAI,IAAI,CAAC,GAAG,EAAE,IAAI,WAAW,CAAC,UAAU;YAAE,OAAO,IAAI,CAAC;QAC/F,IAAI,CAAC,cAAc,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;QACtC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;IACvE,CAAC;IAEM,KAAK,CAAC,GAAG,CAAC,OAAiC;QAChD,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,cAAc,EAAE,CAAC;QACrC,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;QACxC,IAAI,MAAM,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,WAAW,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC;QAC3E,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,cAAc,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC;QAChF,IAAI,MAAM,EAAE,CAAC;YACX,IAAI,CAAC,mBAAmB,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;YAC3C,IAAI,MAAM,EAAE,MAAM,KAAK,OAAO,IAAI,MAAM,CAAC,EAAE,KAAK,MAAM,CAAC,UAAU,IAAI,IAAI,CAAC,GAAG,EAAE,GAAG,MAAM,CAAC,UAAU,EAAE,CAAC;gBACpG,IAAI,CAAC,cAAc,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;gBACtC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;YAC/E,CAAC;QACH,CAAC;QACD,IAAI,MAAM,EAAE,MAAM,KAAK,OAAO,IAAI,CAAC,MAAM,EAAE,CAAC;YAC1C,IAAI,CAAC,cAAc,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;YACtC,OAAO,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;QAC1C,CAAC;QACD,IAAI,CAAC,MAAM,IAAI,MAAM,CAAC,MAAM,KAAK,OAAO,EAAE,CAAC;YACzC,MAAM,CAAC,UAAU,EAAE,GAAG,CAAC,GAAG,MAAM,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC;gBAChE,UAAU,EAAE,QAAQ,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC;aAC7E,CAAC,CAAC;YACH,MAAM,IAAI,GAAyB;gBACjC,GAAG,QAAQ,EAAE,UAAU,EAAE,OAAO,CAAC,MAAM,CAAC,UAAU,EAAE,EAAE,QAAQ,EAAE,CAAC,MAAM,EAAE,QAAQ,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC;gBAC5F,MAAM,EAAE,UAAU,EAAE,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE,EAAE,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE,EAAE,UAAU,EAAE,GAAG;gBACjF,iBAAiB,EAAE,EAAE;aACtB,CAAC;YACF,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,cAAc,EAAE,CAAC;YACrC,IAAI,CAAC,MAAM,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,qBAAqB,CAAC,QAAQ,CAAC,cAAc,EAAE,MAAM,EAAE,QAAQ,IAAI,IAAI,EAAE,IAAI,CAAC,EAAE,CAAC;gBAC7G,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC;gBACnE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;YAC7D,CAAC;YACD,MAAM,GAAG,IAAI,CAAC;QAChB,CAAC;QACD,IAAI,CAAC,cAAc,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;QACtC,OAAO,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IAC3C,CAAC;IAEM,KAAK,CAAC,OAAO,CAAC,OAAsC;QACzD,IAAI,CAAC,CAAC,SAAS,EAAE,wBAAwB,EAAE,SAAS,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC;eACzE,CAAC,MAAM,CAAC,aAAa,CAAC,OAAO,CAAC,gBAAgB,CAAC,IAAI,OAAO,CAAC,gBAAgB,GAAG,CAAC;eAC/E,OAAO,OAAO,CAAC,UAAU,KAAK,QAAQ,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,CAAC;YACnE,MAAM,IAAI,KAAK,CAAC,mCAAmC,CAAC,CAAC;QACvD,CAAC;QACD,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;QACxC,IAAI,MAAM,GAAG,MAAM,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC;QAChE,IAAI,CAAC,cAAc,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;QACtC,IAAI,MAAM,CAAC,UAAU,KAAK,OAAO,CAAC,UAAU,IAAI,MAAM,CAAC,QAAQ,KAAK,OAAO,CAAC,gBAAgB,EAAE,CAAC;YAC7F,MAAM,IAAI,KAAK,CAAC,qCAAqC,CAAC,CAAC;QACzD,CAAC;QACD,IAAI,OAAO,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;YACjC,IAAI,MAAM,CAAC,MAAM,KAAK,OAAO;gBAAE,MAAM,IAAI,KAAK,CAAC,0CAA0C,CAAC,CAAC;YAC3F,MAAM,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,MAAM,EAAE,sBAAsB,EAAE,CAAC,CAAC;YACrE,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;YAC3B,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC,EAAE,CAAC;QACtG,CAAC;QACD,IAAI,MAAM,CAAC,MAAM,KAAK,sBAAsB,EAAE,CAAC;YAC7C,MAAM,IAAI,KAAK,CAAC,+EAA+E,CAAC,CAAC;QACnG,CAAC;QACD,IAAI,OAAO,CAAC,MAAM,KAAK,wBAAwB,EAAE,CAAC;YAChD,0EAA0E;YAC1E,IAAI,MAAM,CAAC,KAAK,IAAI,MAAM,CAAC,MAAM,KAAK,QAAQ,IAAI,MAAM,CAAC,SAAS,KAAK,cAAc,EAAE,CAAC;gBACtF,MAAM,IAAI,KAAK,CAAC,sDAAsD,CAAC,CAAC;YAC1E,CAAC;YACD,IAAI,MAAM,CAAC,UAAU,IAAI,MAAM,CAAC,UAAU,GAAG,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC;gBACxD,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;YAC5D,CAAC;YACD,MAAM,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,MAAM,EAAE,UAAU,EAAE,SAAS,EAAE,SAAS,EAAE,UAAU,EAAE,SAAS,EAAE,CAAC,CAAC;YACtG,OAAO,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;QAC3C,CAAC;QACD,OAAO,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IAC1C,CAAC;IAEO,KAAK,CAAC,OAAO,CAAC,OAA6B,EAAE,WAAoB;QACvE,IAAI,MAAM,GAAG,OAAO,CAAC;QACrB,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,cAAc,EAAE,CAAC;QACrC,IAAI,MAAM,CAAC,MAAM,KAAK,sBAAsB,IAAI,MAAM,CAAC,MAAM,KAAK,QAAQ,EAAE,CAAC;YAC3E,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;QAC5D,CAAC;QACD,IAAI,MAAM,CAAC,MAAM,KAAK,UAAU,IAAI,CAAC,MAAM,CAAC,MAAM,KAAK,eAAe,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;YACzF,MAAM,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,MAAM,EAAE,eAAe,EAAE,SAAS,EAAE,uBAAuB,EAAE,CAAC,CAAC;YAClG,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;QAC5D,CAAC;QACD,IAAI,MAAM,CAAC,MAAM,KAAK,UAAU,EAAE,CAAC;YACjC,IAAI,WAAW;gBAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;YAC3E,oEAAoE;YACpE,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;YAC3B,MAAM,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,MAAM,EAAE,UAAU,EAAE,CAAC,CAAC;YACzD,IAAI,KAA8B,CAAC;YACnC,IAAI,CAAC;gBACH,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,cAAc,EAAE,CAAC;gBACrC,KAAK,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,WAAW,CAAC;oBAC5C,WAAW,EAAE,MAAM,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,CAAC;iBACzE,CAAC,CAAC;YACL,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,MAAM,QAAQ,GAAG,KAAK,YAAY,OAAO,CAAC,IAAI,CAAC,SAAS,IAAI,KAAK,CAAC,aAAa,CAAC;gBAChF,MAAM,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE;oBAC/B,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,eAAe;oBAC7C,SAAS,EAAE,QAAQ,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,uBAAuB;oBAC9D,UAAU,EAAE,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,UAAU,EAAE,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,SAAS;iBACtF,CAAC,CAAC;gBACH,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;YAC5D,CAAC;YACD,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC;gBACf,MAAM,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,MAAM,EAAE,eAAe,EAAE,SAAS,EAAE,uBAAuB,EAAE,CAAC,CAAC;gBAClG,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;YAC5D,CAAC;YACD,MAAM,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,aAAa,EAAE,CAAC,CAAC;QACrE,CAAC;QACD,IAAI,CAAC,MAAM,CAAC,KAAK;YAAE,MAAM,IAAI,KAAK,CAAC,2CAA2C,CAAC,CAAC;QAChF,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QACtE,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;QACrC,MAAM,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,SAAS,EAAE,CAAC,CAAC;QAC5E,IAAI,QAAQ,CAAC,MAAM,KAAK,SAAS,IAAI,QAAQ,CAAC,MAAM,KAAK,SAAS,IAAI,QAAQ,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;YACpG,MAAM,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,eAAe,EAAE,CAAC,CAAC;YACnF,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;YAC3B,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC,EAAE,CAAC;QACtG,CAAC;QACD,IAAI,QAAQ,CAAC,MAAM,KAAK,OAAO;YAAE,OAAO,MAAM,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QAClE,IAAI,WAAW,EAAE,CAAC;YAChB,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;QAC5D,CAAC;QACD,IAAI,MAAM,CAAC,MAAM,KAAK,YAAY,IAAI,MAAM,CAAC,MAAM,KAAK,eAAe,EAAE,CAAC;YACxE,qEAAqE;YACrE,uEAAuE;YACvE,MAAM,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,MAAM,EAAE,eAAe,EAAE,SAAS,EAAE,uBAAuB,EAAE,CAAC,CAAC;YAClG,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;QAC5D,CAAC;QACD,IAAI,QAAQ,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;YAClC,MAAM,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;YACtC,IAAI,MAAM,CAAC,MAAM,KAAK,QAAQ;gBAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;QAC5F,CAAC;QACD,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,KAAM,CAAC,GAAG,CAAC,CAAC;QACpE,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;QAClC,MAAM,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,CAAC;QACnD,IAAI,KAAK,CAAC,MAAM,KAAK,OAAO;YAAE,OAAO,MAAM,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QAC/D,IAAI,KAAK,CAAC,MAAM,KAAK,OAAO,EAAE,CAAC;YAC7B,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;QAC5D,CAAC;QACD,MAAM,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,MAAM,EAAE,YAAY,EAAE,CAAC,CAAC;QAC3D,IAAI,CAAC;YACH,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,cAAc,EAAE,CAAC;YACrC,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,aAAa,CAAC,eAAe,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC;QAC9E,CAAC;QAAC,MAAM,CAAC;YACP,yEAAyE;YACzE,MAAM,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,MAAM,EAAE,eAAe,EAAE,SAAS,EAAE,uBAAuB,EAAE,CAAC,CAAC;YAClG,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;QAC5D,CAAC;QACD,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAChE,IAAI,CAAC,aAAa,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;QACtC,MAAM,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC,CAAC;QACvD,OAAO,SAAS,CAAC,MAAM,KAAK,OAAO;YACjC,CAAC,CAAC,MAAM,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC;YAC3B,CAAC,CAAC,EAAE,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;IACzD,CAAC;IAEO,KAAK,CAAC,SAAS,CAAC,OAA6B;QACnD,IAAI,MAAM,GAAG,OAAO,CAAC;QACrB,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;QAC3C,MAAM,cAAc,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,iBAAiB,CAAC,MAAM,CAAC,KAAM,CAAC,CAAC;QAClF,KAAK,MAAM,aAAa,IAAI,cAAc,EAAE,CAAC;YAC3C,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,cAAc,EAAE,CAAC;YACrC,MAAM,UAAU,GAAG,GAAG,aAAa,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,GAAG,aAAa,CAAC,UAAU,CAAC,KAAK,EAAE,CAAC;YAC5F,IAAI,aAAa,CAAC,UAAU,CAAC,IAAI,KAAK,KAAK,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC;gBACxF,MAAM,IAAI,KAAK,CAAC,uDAAuD,CAAC,CAAC;YAC3E,CAAC;YACD,IAAI,aAAa,CAAC,MAAM,KAAK,OAAO;gBAAE,SAAS;YAC/C,IAAI,aAAa,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;gBACvC,OAAO,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,sBAAsB,EAAE,CAAC,CAAC;YAC1F,CAAC;YACD,MAAM,SAAS,GAAG,aAAa,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,KAAK,QAAQ,CAAC,CAAC;YACpF,IAAI,CAAC,SAAS;gBAAE,MAAM,IAAI,KAAK,CAAC,6BAA6B,CAAC,CAAC;YAC/D,MAAM,KAAK,GAAG;gBACZ,QAAQ,EAAE,mBAAmB,aAAa,CAAC,UAAU,CAAC,KAAK,EAAE;gBAC7D,SAAS,EAAE,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,4BAA4B,CAAC,SAAS,CAAC;aACvE,CAAC;YACF,IAAI,CAAC,MAAM,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,QAAQ,KAAK,KAAK,CAAC,QAAQ,IAAI,KAAK,CAAC,SAAS,KAAK,KAAK,CAAC,SAAS,CAAC,EAAE,CAAC;gBACxH,MAAM,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,iBAAiB,EAAE,CAAC,GAAG,MAAM,CAAC,iBAAiB,EAAE,KAAK,CAAC,EAAE,CAAC,CAAC;YAChG,CAAC;YACD,IAAI,CAAC;gBACH,MAAM,OAAO,CAAC,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC,CAAC;gBAC5D,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;oBACnB,MAAM,OAAO,CAAC,MAAM,CAAC,KAAK,EAAE,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC,CAAC;gBAC7D,CAAC;qBAAM,CAAC;oBACN,IAAI,OAAO,GAAG,KAAK,CAAC;oBACpB,KAAK,IAAI,OAAO,GAAG,CAAC,EAAE,OAAO,GAAG,GAAG,EAAE,OAAO,EAAE,EAAE,CAAC;wBAC/C,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,cAAc,EAAE,CAAC;wBACrC,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,UAAU,CAAC,KAAK,CAAC,QAAQ,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC;wBAC5E,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,KAAK,KAAK,KAAK,CAAC,SAAS,CAAC,EAAE,CAAC;4BAAC,OAAO,GAAG,IAAI,CAAC;4BAAC,MAAM;wBAAC,CAAC;wBACxF,MAAM,OAAO,CAAC,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE,SAAS,EAAE,EAAE,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;oBACpF,CAAC;oBACD,IAAI,CAAC,OAAO;wBAAE,MAAM,IAAI,KAAK,CAAC,8BAA8B,CAAC,CAAC;gBAChE,CAAC;gBACD,MAAM,OAAO,CAAC,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,qBAAqB,EAAE,SAAS,EAAE,EAAE,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;gBAChH,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC;gBACvD,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,kBAAkB,CAAC,SAAS,CAAC,CAAC;YAC1D,CAAC;oBAAS,CAAC;gBACT,oEAAoE;gBACpE,sEAAsE;gBACtE,MAAM,OAAO,CAAC,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC,CAAC;gBAC5D,MAAM,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE;oBAC/B,iBAAiB,EAAE,MAAM,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,QAAQ,KAAK,KAAK,CAAC,QAAQ,IAAI,KAAK,CAAC,SAAS,KAAK,KAAK,CAAC,SAAS,CAAC;iBACxI,CAAC,CAAC;YACL,CAAC;QACH,CAAC;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;IAEO,KAAK,CAAC,MAAM,CAAC,OAA6B;QAChD,IAAI,MAAM,GAAG,OAAO,CAAC;QACrB,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,WAAW;YAAE,MAAM,IAAI,KAAK,CAAC,wCAAwC,CAAC,CAAC;QAC1F,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,cAAc,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QACnE,MAAM,IAAI,GAAG,IAAI,OAAO,CAAC,MAAM,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC;QACrD,MAAM,SAAS,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,OAAO,EAAE,CAAC;QACrD,MAAM,UAAU,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,OAAO,EAAE,CAAC;QACpD,MAAM,WAAW,GAAsB;YACrC,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,UAAU,EAAE,OAAO,EAAE,IAAI,CAAC,GAAG,EAAE;YACpE,UAAU,EAAE,MAAM,CAAC,UAAU,EAAE,GAAG,EAAE,MAAM,CAAC,GAAG,EAAE,SAAS,EAAE,GAAG,EAAE,SAAS,EAAE,UAAU;YACrF,UAAU,EAAE,UAAU,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,QAAQ,EAAE,CAAC,UAAU,GAAG,SAAS,CAAC,GAAG,CAAC,CAAC;SAC/E,CAAC;QACF,IAAI,CAAC;YACH,IAAI,CAAC,mBAAmB,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC;YAC9C,IAAI,UAAU,IAAI,IAAI,CAAC,GAAG,EAAE;gBAAE,MAAM,IAAI,KAAK,CAAC,oCAAoC,CAAC,CAAC;QACtF,CAAC;QAAC,MAAM,CAAC;YACP,MAAM,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,qBAAqB,EAAE,CAAC,CAAC;YACzF,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;QAC5D,CAAC;QACD,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;QAC3B,MAAM,GAAG,MAAM,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC;QAC1D,IAAI,MAAM,CAAC,MAAM,KAAK,sBAAsB,EAAE,CAAC;YAC7C,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;QAC5D,CAAC;QACD,MAAM,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,gBAAgB,CAAC,WAAW,CAAC,CAAC;QACvD,MAAM,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,CAAC,CAAC;QAC5E,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;IACvE,CAAC;IAEO,KAAK,CAAC,OAAO,CAAC,MAAiC;QACrD,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,iBAAiB,EAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC;QACpG,IAAI,CAAC,OAAO;YAAE,MAAM,IAAI,KAAK,CAAC,gCAAgC,CAAC,CAAC;QAChE,KAAK,MAAM,UAAU,IAAI,MAAM,CAAC,WAAW,EAAE,CAAC;YAC5C,IAAI,CAAC,MAAM,OAAO,CAAC,4BAA4B,CAAC,UAAU,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC;gBACjF,MAAM,IAAI,KAAK,CAAC,4DAA4D,CAAC,CAAC;YAChF,CAAC;QACH,CAAC;QACD,OAAO,OAAO,CAAC;IACjB,CAAC;IAEO,KAAK,CAAC,OAAO,CAAC,OAA6B;QACjD,IAAI,MAAM,GAAG,OAAO,CAAC;QACrB,IAAI,CAAC,MAAM,CAAC,iBAAiB,CAAC,MAAM;YAAE,OAAO;QAC7C,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,iBAAiB,EAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC;QACpG,IAAI,CAAC,OAAO;YAAE,MAAM,IAAI,KAAK,CAAC,uCAAuC,CAAC,CAAC;QACvE,KAAK,MAAM,KAAK,IAAI,CAAC,GAAG,MAAM,CAAC,iBAAiB,CAAC,EAAE,CAAC;YAClD,MAAM,OAAO,CAAC,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC,CAAC;YAC5D,MAAM,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE;gBAC/B,iBAAiB,EAAE,MAAM,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,QAAQ,KAAK,KAAK,CAAC,QAAQ,IAAI,KAAK,CAAC,SAAS,KAAK,KAAK,CAAC,SAAS,CAAC;aACxI,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IAEO,gBAAgB,CAAC,MAA4B;QACnD,OAAO,EAAE,WAAW,EAAE,OAAO,CAAC,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC;iBACtD,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,8BAA8B,EAAE,MAAM,CAAC,cAAc,EAAE,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;IACxH,CAAC;IAEO,cAAc,CAAC,MAA4B,EAAE,QAAmC;QACtF,IAAI,MAAM,CAAC,cAAc,KAAK,QAAQ,CAAC,cAAc;eAChD,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,cAAc,KAAK,QAAQ,CAAC,cAAc;eAChE,MAAM,CAAC,iBAAiB,KAAK,QAAQ,CAAC,iBAAiB,IAAI,MAAM,CAAC,YAAY,KAAK,QAAQ,CAAC,YAAY,EAAE,CAAC;YAC9G,MAAM,IAAI,KAAK,CAAC,oCAAoC,CAAC,CAAC;QACxD,CAAC;IACH,CAAC;IAEO,aAAa,CAAC,KAA8B,EAAE,MAA4B;QAChF,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,KAAK,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,KAAK,KAAK,CAAC;eACpE,IAAI,CAAC,SAAS,CAAC,+BAA+B,CAAC,KAAK,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,WAAW,CAAC,EAAE,CAAC;YAC3I,MAAM,IAAI,KAAK,CAAC,2DAA2D,CAAC,CAAC;QAC/E,CAAC;IACH,CAAC;IAEO,mBAAmB,CAAC,WAA8B,EAAE,QAAmC;QAC7F,IAAI,WAAW,CAAC,cAAc,KAAK,QAAQ,CAAC,cAAc;eACrD,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC,cAAc,KAAK,QAAQ,CAAC,cAAc;eACrE,WAAW,CAAC,iBAAiB,KAAK,QAAQ,CAAC,iBAAiB,IAAI,WAAW,CAAC,YAAY,KAAK,QAAQ,CAAC,YAAY,EAAE,CAAC;YACxH,MAAM,IAAI,KAAK,CAAC,uCAAuC,CAAC,CAAC;QAC3D,CAAC;QACD,MAAM,MAAM,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC,eAAe,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC;QACvE,MAAM,KAAK,GAAG,MAAM,CAAC,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,+BAA+B,CAAC,EAAE,KAAK,CAAC,MAAM,EAAE,CAAC;QAChG,IAAI,CAAC,KAAK,IAAI,KAAK,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,KAAK,KAAK,CAAC;eACpD,IAAI,CAAC,SAAS,CAAC,+BAA+B,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC;YACjI,MAAM,IAAI,KAAK,CAAC,mEAAmE,CAAC,CAAC;QACvF,CAAC;QACD,MAAM,IAAI,GAAG,IAAI,OAAO,CAAC,MAAM,CAAC,eAAe,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC;QACvE,IAAI,IAAI,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,MAAM,CAAC,gBAAgB,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC;eACxF,IAAI,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,OAAO,EAAE,KAAK,WAAW,CAAC,SAAS;eAC5D,IAAI,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,OAAO,EAAE,KAAK,WAAW,CAAC,UAAU;eAC3D,WAAW,CAAC,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,MAAM;eAC3C,CAAC,MAAM,CAAC,QAAQ,CAAC,WAAW,CAAC,UAAU,CAAC,IAAI,WAAW,CAAC,UAAU,IAAI,WAAW,CAAC,UAAU,EAAE,CAAC;YAClG,MAAM,IAAI,KAAK,CAAC,mDAAmD,CAAC,CAAC;QACvE,CAAC;IACH,CAAC;IAEO,IAAI,CAAC,MAA4B;QACvC,OAAO;YACL,cAAc,EAAE,MAAM,CAAC,cAAc,EAAE,UAAU,EAAE,MAAM,CAAC,UAAU;YACpE,WAAW,EAAE,CAAC,GAAG,MAAM,CAAC,WAAW,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,EAAE,MAAM,CAAC,QAAQ;YACtF,SAAS,EAAE,MAAM,CAAC,SAAS,EAAE,SAAS,EAAE,MAAM,CAAC,SAAS;YACxD,SAAS,EAAE,MAAM,CAAC,SAAS,EAAE,UAAU,EAAE,MAAM,CAAC,UAAU;SAC3D,CAAC;IACJ,CAAC;IAEO,KAAK,CAAC,cAAc,CAAC,GAAW;QACtC,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;QACzD,IAAI,CAAC,MAAM;YAAE,MAAM,IAAI,KAAK,CAAC,qCAAqC,CAAC,CAAC;QACpE,OAAO,MAAM,CAAC;IAChB,CAAC;IAEO,KAAK,CAAC,IAAI,CAAC,MAA4B,EAAE,KACwB;QACvE,MAAM,IAAI,GAAG,EAAE,GAAG,MAAM,EAAE,GAAG,KAAK,EAAE,QAAQ,EAAE,MAAM,CAAC,QAAQ,GAAG,CAAC,EAAE,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC;QAC3F,IAAI,CAAC,MAAM,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,qBAAqB,CAAC,MAAM,CAAC,cAAc,EAAE,MAAM,CAAC,QAAQ,EAAE,IAAI,CAAC,EAAE,CAAC;YAClG,MAAM,IAAI,KAAK,CAAC,2EAA2E,CAAC,CAAC;QAC/F,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;CACF"}

package/dist_ts/handlers/IChallengeHandler.d.ts

@@ -1,3 +1,8 @@
+/** Stable resource owner across preparation, retries, cleanup and exact recovery. */
+export interface IChallengeContext {
+    /** Opaque identity for one order attempt; never reuse resources across owners. */
+    operationId: string;
+}
 /**
  * Pluggable interface for ACME challenge handlers.
  * Supports DNS-01, HTTP-01, TLS-ALPN-01, or custom challenge types.
@@ -10,14 +15,14 @@ export interface IChallengeHandler<T> {
     /**
      * Prepare the challenge: set DNS record, start HTTP/TLS server, etc.
      */
-    prepare(ch: T): Promise<void>;
+    prepare(ch: T, context?: IChallengeContext): Promise<void>;
     /**
      * Optional extra verify step (HTTP GET, ALPN handshake).
      */
-    verify?(ch: T): Promise<void>;
+    verify?(ch: T, context?: IChallengeContext): Promise<void>;
     /**
      * Clean up resources: remove DNS record, stop server.
      */
-    cleanup(ch: T): Promise<void>;
+    cleanup(ch: T, context?: IChallengeContext): Promise<void>;
     checkWetherDomainIsSupported(domainArg: string): Promise<boolean>;
 }

package/dist_ts/handlers/index.d.ts

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

package/dist_ts/index.d.ts

@@ -1,6 +1,8 @@
 export * from './smartacme.classes.smartacme.js';
 export { SmartacmeCert as Cert } from './smartacme.classes.cert.js';
 export type { ICertManager } from './interfaces/certmanager.js';
+export type * from './interfaces/exact-issuance.js';
+export { normalizeCertificateIdentifiers } from './classes.exact-certificate-issuer.js';
 import * as certmanagers from './certmanagers/index.js';
 export { certmanagers };
 import * as handlers from './handlers/index.js';

package/dist_ts/index.js

@@ -1,5 +1,6 @@
 export * from './smartacme.classes.smartacme.js';
 export { SmartacmeCert as Cert } from './smartacme.classes.cert.js';
+export { normalizeCertificateIdentifiers } from './classes.exact-certificate-issuer.js';
 // certmanagers
 import * as certmanagers from './certmanagers/index.js';
 export { certmanagers };
@@ -9,4 +10,4 @@ export { handlers };
 // server (ACME Directory Server / CA)
 import * as server from '../dist_ts_server/index.js';
 export { server };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGtDQUFrQyxDQUFDO0FBQ2pELE9BQU8sRUFBRSxhQUFhLElBQUksSUFBSSxFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFHcEUsZUFBZTtBQUNmLE9BQU8sS0FBSyxZQUFZLE1BQU0seUJBQXlCLENBQUM7QUFDeEQsT0FBTyxFQUFFLFlBQVksRUFBRSxDQUFDO0FBRXhCLFdBQVc7QUFDWCxPQUFPLEtBQUssUUFBUSxNQUFNLHFCQUFxQixDQUFDO0FBQ2hELE9BQU8sRUFBRSxRQUFRLEVBQUUsQ0FBQztBQUVwQixzQ0FBc0M7QUFDdEMsT0FBTyxLQUFLLE1BQU0sTUFBTSx1QkFBdUIsQ0FBQztBQUNoRCxPQUFPLEVBQUUsTUFBTSxFQUFFLENBQUMifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGtDQUFrQyxDQUFDO0FBQ2pELE9BQU8sRUFBRSxhQUFhLElBQUksSUFBSSxFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFHcEUsT0FBTyxFQUFFLCtCQUErQixFQUFFLE1BQU0sdUNBQXVDLENBQUM7QUFFeEYsZUFBZTtBQUNmLE9BQU8sS0FBSyxZQUFZLE1BQU0seUJBQXlCLENBQUM7QUFDeEQsT0FBTyxFQUFFLFlBQVksRUFBRSxDQUFDO0FBRXhCLFdBQVc7QUFDWCxPQUFPLEtBQUssUUFBUSxNQUFNLHFCQUFxQixDQUFDO0FBQ2hELE9BQU8sRUFBRSxRQUFRLEVBQUUsQ0FBQztBQUVwQixzQ0FBc0M7QUFDdEMsT0FBTyxLQUFLLE1BQU0sTUFBTSx1QkFBdUIsQ0FBQztBQUNoRCxPQUFPLEVBQUUsTUFBTSxFQUFFLENBQUMifQ==

package/dist_ts/interfaces/exact-issuance.d.ts

@@ -0,0 +1,79 @@
+import type { IAcmeOrder } from '../acme/acme.interfaces.js';
+/** Explicit identifiers never inherit parent or wildcard coverage. */
+export interface IExactCertificateRequest {
+    namespace: string;
+    identifiers: string[];
+}
+export interface IExactCertificateIdentity extends IExactCertificateRequest {
+    certificateKey: string;
+    directoryUrl: string;
+    accountThumbprint: string;
+}
+export interface IExactCertificate extends IExactCertificateIdentity {
+    id: string;
+    privateKey: string;
+    publicKey: string;
+    csr: string;
+    created: number;
+    validFrom: number;
+    validUntil: number;
+    renewAfter: number;
+}
+export type TExactIssuanceStatus = 'prepared' | 'creating' | 'authorizing' | 'finalizing' | 'ready' | 'failed' | 'indeterminate' | 'abandoned_unverified';
+export type TExactIssuanceErrorCode = 'order_outcome_unknown' | 'order_invalid' | 'authorization_failed' | 'certificate_invalid' | 'challenge_cleanup_pending' | 'rate_limited' | 'transport_unavailable';
+export interface IExactDnsChallenge {
+    hostName: string;
+    challenge: string;
+}
+/** Sensitive durable state. Never return this record through a status API. */
+export interface IExactIssuanceRecord extends IExactCertificateIdentity {
+    issuanceId: string;
+    revision: number;
+    status: TExactIssuanceStatus;
+    createdAt: number;
+    updatedAt: number;
+    privateKey: string;
+    csr: string;
+    order?: IAcmeOrder;
+    pendingChallenges: IExactDnsChallenge[];
+    errorCode?: TExactIssuanceErrorCode;
+    retryAfter?: number;
+}
+/**
+ * Storage must acknowledge durable writes and atomically compare revisions.
+ * A null revision means insert only if absent. No filesystem fallback is used.
+ * Keep unresolved records until their external outcome has been reconciled.
+ */
+export interface IExactIssuanceStore {
+    getAccountKey(accountId: string): Promise<string | null>;
+    createAccountKey(accountId: string, privateKey: string): Promise<boolean>;
+    getIssuance(certificateKey: string): Promise<IExactIssuanceRecord | null>;
+    compareAndSetIssuance(certificateKey: string, expectedRevision: number | null, record: IExactIssuanceRecord): Promise<boolean>;
+    getCertificate(certificateKey: string): Promise<IExactCertificate | null>;
+    storeCertificate(certificate: IExactCertificate): Promise<void>;
+}
+/** Safe status projection; contains neither keys nor challenge material. */
+export interface IExactIssuanceInfo {
+    certificateKey: string;
+    issuanceId: string;
+    identifiers: string[];
+    status: TExactIssuanceStatus;
+    revision: number;
+    createdAt: number;
+    updatedAt: number;
+    errorCode?: TExactIssuanceErrorCode;
+    retryAfter?: number;
+}
+export type TExactCertificateResult = {
+    status: 'ready';
+    certificate: IExactCertificate;
+    issuance: IExactIssuanceInfo;
+} | {
+    status: 'pending';
+    issuance: IExactIssuanceInfo;
+};
+export interface IExactIssuanceRecoveryRequest extends IExactCertificateRequest {
+    issuanceId: string;
+    expectedRevision: number;
+    action: 'recheck' | 'retry-proven-unapplied' | 'abandon';
+}

package/dist_ts/interfaces/exact-issuance.js

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

package/dist_ts/plugins.d.ts

@@ -1,8 +1,12 @@
 import 'reflect-metadata';
 import * as crypto from 'node:crypto';
+import * as url from 'node:url';
+import * as net from 'node:net';
+import * as timers from 'node:timers/promises';
+import * as x509 from '@peculiar/x509';
 import * as fs from 'fs';
 import * as path from 'path';
-export { crypto, fs, path };
+export { crypto, fs, path, url, net, timers, x509 };
 import * as cloudflare from '@apiclient.xyz/cloudflare';
 export { cloudflare };
 import * as lik from '@push.rocks/lik';

package/dist_ts/plugins.js

@@ -2,9 +2,13 @@
 import 'reflect-metadata';
 // node native
 import * as crypto from 'node:crypto';
+import * as url from 'node:url';
+import * as net from 'node:net';
+import * as timers from 'node:timers/promises';
+import * as x509 from '@peculiar/x509';
 import * as fs from 'fs';
 import * as path from 'path';
-export { crypto, fs, path };
+export { crypto, fs, path, url, net, timers, x509 };
 // @apiclient.xyz scope
 import * as cloudflare from '@apiclient.xyz/cloudflare';
 export { cloudflare };
@@ -29,4 +33,4 @@ export { acme };
 // local handlers for challenge types
 import * as handlers from './handlers/index.js';
 export { handlers };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEseUVBQXlFO0FBQ3pFLE9BQU8sa0JBQWtCLENBQUM7QUFFMUIsY0FBYztBQUNkLE9BQU8sS0FBSyxNQUFNLE1BQU0sYUFBYSxDQUFDO0FBQ3RDLE9BQU8sS0FBSyxFQUFFLE1BQU0sSUFBSSxDQUFDO0FBQ3pCLE9BQU8sS0FBSyxJQUFJLE1BQU0sTUFBTSxDQUFDO0FBRTdCLE9BQU8sRUFBRSxNQUFNLEVBQUUsRUFBRSxFQUFFLElBQUksRUFBRSxDQUFDO0FBRTVCLHVCQUF1QjtBQUN2QixPQUFPLEtBQUssVUFBVSxNQUFNLDJCQUEyQixDQUFDO0FBRXhELE9BQU8sRUFBRSxVQUFVLEVBQUUsQ0FBQztBQUV0QixvQkFBb0I7QUFDcEIsT0FBTyxLQUFLLEdBQUcsTUFBTSxpQkFBaUIsQ0FBQztBQUN2QyxPQUFPLEtBQUssU0FBUyxNQUFNLHVCQUF1QixDQUFDO0FBQ25ELE9BQU8sS0FBSyxVQUFVLE1BQU0sd0JBQXdCLENBQUM7QUFDckQsT0FBTyxLQUFLLGNBQWMsTUFBTSw2QkFBNkIsQ0FBQztBQUM5RCxPQUFPLEtBQUssUUFBUSxNQUFNLHNCQUFzQixDQUFDO0FBQ2pELE9BQU8sS0FBSyxZQUFZLE1BQU0sMEJBQTBCLENBQUM7QUFDekQsT0FBTyxLQUFLLFdBQVcsTUFBTSx5QkFBeUIsQ0FBQztBQUN2RCxPQUFPLEtBQUssV0FBVyxNQUFNLHlCQUF5QixDQUFDO0FBQ3ZELE9BQU8sS0FBSyxTQUFTLE1BQU0sdUJBQXVCLENBQUM7QUFDbkQsT0FBTyxLQUFLLFVBQVUsTUFBTSx3QkFBd0IsQ0FBQztBQUVyRCxPQUFPLEVBQ0wsR0FBRyxFQUNILFNBQVMsRUFDVCxVQUFVLEVBQ1YsY0FBYyxFQUNkLFFBQVEsRUFDUixZQUFZLEVBQ1osV0FBVyxFQUNYLFdBQVcsRUFDWCxTQUFTLEVBQ1QsVUFBVSxHQUNYLENBQUM7QUFFRixpQkFBaUI7QUFDakIsT0FBTyxLQUFLLE9BQU8sTUFBTSxrQkFBa0IsQ0FBQztBQUU1QyxPQUFPLEVBQUUsT0FBTyxFQUFFLENBQUM7QUFFbkIsd0NBQXdDO0FBQ3hDLE9BQU8sS0FBSyxJQUFJLE1BQU0saUJBQWlCLENBQUM7QUFFeEMsT0FBTyxFQUFFLElBQUksRUFBRSxDQUFDO0FBQ2hCLHFDQUFxQztBQUNyQyxPQUFPLEtBQUssUUFBUSxNQUFNLHFCQUFxQixDQUFDO0FBQ2hELE9BQU8sRUFBRSxRQUFRLEVBQUUsQ0FBQyJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEseUVBQXlFO0FBQ3pFLE9BQU8sa0JBQWtCLENBQUM7QUFFMUIsY0FBYztBQUNkLE9BQU8sS0FBSyxNQUFNLE1BQU0sYUFBYSxDQUFDO0FBQ3RDLE9BQU8sS0FBSyxHQUFHLE1BQU0sVUFBVSxDQUFDO0FBQ2hDLE9BQU8sS0FBSyxHQUFHLE1BQU0sVUFBVSxDQUFDO0FBQ2hDLE9BQU8sS0FBSyxNQUFNLE1BQU0sc0JBQXNCLENBQUM7QUFDL0MsT0FBTyxLQUFLLElBQUksTUFBTSxnQkFBZ0IsQ0FBQztBQUN2QyxPQUFPLEtBQUssRUFBRSxNQUFNLElBQUksQ0FBQztBQUN6QixPQUFPLEtBQUssSUFBSSxNQUFNLE1BQU0sQ0FBQztBQUU3QixPQUFPLEVBQUUsTUFBTSxFQUFFLEVBQUUsRUFBRSxJQUFJLEVBQUUsR0FBRyxFQUFFLEdBQUcsRUFBRSxNQUFNLEVBQUUsSUFBSSxFQUFFLENBQUM7QUFFcEQsdUJBQXVCO0FBQ3ZCLE9BQU8sS0FBSyxVQUFVLE1BQU0sMkJBQTJCLENBQUM7QUFFeEQsT0FBTyxFQUFFLFVBQVUsRUFBRSxDQUFDO0FBRXRCLG9CQUFvQjtBQUNwQixPQUFPLEtBQUssR0FBRyxNQUFNLGlCQUFpQixDQUFDO0FBQ3ZDLE9BQU8sS0FBSyxTQUFTLE1BQU0sdUJBQXVCLENBQUM7QUFDbkQsT0FBTyxLQUFLLFVBQVUsTUFBTSx3QkFBd0IsQ0FBQztBQUNyRCxPQUFPLEtBQUssY0FBYyxNQUFNLDZCQUE2QixDQUFDO0FBQzlELE9BQU8sS0FBSyxRQUFRLE1BQU0sc0JBQXNCLENBQUM7QUFDakQsT0FBTyxLQUFLLFlBQVksTUFBTSwwQkFBMEIsQ0FBQztBQUN6RCxPQUFPLEtBQUssV0FBVyxNQUFNLHlCQUF5QixDQUFDO0FBQ3ZELE9BQU8sS0FBSyxXQUFXLE1BQU0seUJBQXlCLENBQUM7QUFDdkQsT0FBTyxLQUFLLFNBQVMsTUFBTSx1QkFBdUIsQ0FBQztBQUNuRCxPQUFPLEtBQUssVUFBVSxNQUFNLHdCQUF3QixDQUFDO0FBRXJELE9BQU8sRUFDTCxHQUFHLEVBQ0gsU0FBUyxFQUNULFVBQVUsRUFDVixjQUFjLEVBQ2QsUUFBUSxFQUNSLFlBQVksRUFDWixXQUFXLEVBQ1gsV0FBVyxFQUNYLFNBQVMsRUFDVCxVQUFVLEdBQ1gsQ0FBQztBQUVGLGlCQUFpQjtBQUNqQixPQUFPLEtBQUssT0FBTyxNQUFNLGtCQUFrQixDQUFDO0FBRTVDLE9BQU8sRUFBRSxPQUFPLEVBQUUsQ0FBQztBQUVuQix3Q0FBd0M7QUFDeEMsT0FBTyxLQUFLLElBQUksTUFBTSxpQkFBaUIsQ0FBQztBQUV4QyxPQUFPLEVBQUUsSUFBSSxFQUFFLENBQUM7QUFDaEIscUNBQXFDO0FBQ3JDLE9BQU8sS0FBSyxRQUFRLE1BQU0scUJBQXFCLENBQUM7QUFDaEQsT0FBTyxFQUFFLFFBQVEsRUFBRSxDQUFDIn0=