@serve.zone/coremail 1.0.0

package/dist_ts/classes.desiredstate.d.ts

@@ -0,0 +1,40 @@
+import * as plugins from './plugins.js';
+import { type ICoreMailModels } from './classes.models.js';
+import { CoreMailStorage } from './classes.storage.js';
+import { CoreMailTransferService } from './classes.transfer.js';
+import type { ICoreMailReplicaRuntime } from './interfaces.js';
+type TCoreMailDesiredState = plugins.serveZoneInterfaces.data.ICoreMailDesiredState;
+type TCoreMailStatus = plugins.serveZoneInterfaces.data.ICoreMailReconciliationStatus;
+export declare class CoreMailDesiredStateService {
+    private readonly database;
+    private readonly models;
+    private readonly storage;
+    private readonly transfers;
+    private readonly replica;
+    private readonly activeSessionCounts;
+    private readonly now;
+    private activeDesiredState;
+    private activeStatePointer;
+    private refreshTask;
+    constructor(database: plugins.smartdata.SmartdataDb, models: ICoreMailModels, storage: CoreMailStorage, transfers: CoreMailTransferService, replica: ICoreMailReplicaRuntime, activeSessionCounts: (bindingArg: plugins.serveZoneInterfaces.data.ICoreMailBindingDesiredState, configEpochArg: number) => Array<{
+        credentialId: string;
+        version: number;
+        count: number;
+    }>, now?: () => number);
+    private controlAuthority;
+    start(): Promise<void>;
+    getActiveDesiredState: () => Promise<TCoreMailDesiredState | null>;
+    private refresh;
+    private refreshFromPointer;
+    private loadDesiredState;
+    private parseDesiredState;
+    prepare(requestArg: plugins.serveZoneInterfaces.requests.coremail.IReq_CoreMailPrepareDesiredStateUpload['request']): Promise<{
+        reconciliationId: string;
+        grant: plugins.serveZoneInterfaces.data.ICoreMailUploadGrant;
+        replayed: boolean;
+    }>;
+    apply(requestArg: plugins.serveZoneInterfaces.requests.coremail.IReq_CoreMailApplyDesiredState['request']): Promise<TCoreMailStatus>;
+    getStatus(requestArg: plugins.serveZoneInterfaces.requests.coremail.IReq_CoreMailGetReconciliationStatus['request']): Promise<TCoreMailStatus>;
+    private createStatus;
+}
+export {};

package/dist_ts/classes.desiredstate.js

@@ -0,0 +1,382 @@
+import * as plugins from './plugins.js';
+import {} from './classes.models.js';
+import { CoreMailStorage, createSha256 } from './classes.storage.js';
+import { CoreMailTransferService } from './classes.transfer.js';
+import { logCoreMailFailure } from './coremail.log.js';
+import { withCoreMailTransaction } from './coremail.quota.js';
+import { requireCoreMailSafeInteger, requireCoreMailUuid, } from './coremail.selectors.js';
+const emptyStateDigest = createSha256('');
+export class CoreMailDesiredStateService {
+    database;
+    models;
+    storage;
+    transfers;
+    replica;
+    activeSessionCounts;
+    now;
+    activeDesiredState = null;
+    activeStatePointer;
+    refreshTask = null;
+    constructor(database, models, storage, transfers, replica, activeSessionCounts, now = Date.now) {
+        this.database = database;
+        this.models = models;
+        this.storage = storage;
+        this.transfers = transfers;
+        this.replica = replica;
+        this.activeSessionCounts = activeSessionCounts;
+        this.now = now;
+    }
+    controlAuthority() {
+        return {
+            kind: 'control',
+            tenantId: '-',
+            serviceId: this.replica.serviceId,
+            bindingId: '-',
+        };
+    }
+    async start() {
+        const initialized = await this.models.State.exact.insert({
+            stateId: 'active',
+            appliedConfigEpoch: 0,
+            appliedDesiredStateDigest: emptyStateDigest,
+            snapshotId: '-',
+            updatedAt: this.now(),
+        });
+        const state = initialized.document;
+        if (!state) {
+            throw new Error('CoreMail could not initialize its desired-state pointer.');
+        }
+        this.activeStatePointer = state;
+        await this.refreshFromPointer(state);
+    }
+    getActiveDesiredState = async () => {
+        await this.refresh();
+        return this.activeDesiredState;
+    };
+    async refresh() {
+        if (this.refreshTask) {
+            await this.refreshTask;
+            return;
+        }
+        const task = (async () => {
+            const pointer = await this.models.State.exact.findStoredOne({
+                stateId: 'active',
+            });
+            if (!pointer) {
+                throw new Error('CoreMail desired-state pointer is unavailable.');
+            }
+            await this.refreshFromPointer(pointer);
+        })();
+        this.refreshTask = task;
+        try {
+            await task;
+        }
+        finally {
+            if (this.refreshTask === task) {
+                this.refreshTask = null;
+            }
+        }
+    }
+    async refreshFromPointer(pointerArg) {
+        if (pointerArg.appliedConfigEpoch === 0) {
+            this.activeStatePointer = pointerArg;
+            this.activeDesiredState = null;
+            return;
+        }
+        if (this.activeDesiredState?.configEpoch === pointerArg.appliedConfigEpoch
+            && this.activeStatePointer?.snapshotId === pointerArg.snapshotId
+            && this.activeStatePointer.appliedDesiredStateDigest
+                === pointerArg.appliedDesiredStateDigest) {
+            this.activeStatePointer = pointerArg;
+            return;
+        }
+        const desiredState = await this.loadDesiredState(pointerArg);
+        this.activeStatePointer = pointerArg;
+        this.activeDesiredState = desiredState;
+    }
+    async loadDesiredState(stateArg) {
+        const snapshot = await this.models.DesiredSnapshot.exact.findStoredOne({
+            snapshotId: stateArg.snapshotId,
+            configEpoch: stateArg.appliedConfigEpoch,
+            desiredStateDigest: stateArg.appliedDesiredStateDigest,
+        });
+        if (!snapshot
+            || (snapshot.state !== 'staged' && snapshot.state !== 'active')) {
+            throw new Error('CoreMail active desired-state snapshot is unavailable.');
+        }
+        const bytes = await this.storage.getVerifiedBytes(snapshot.objectKey, snapshot.lengthBytes, snapshot.desiredStateDigest, plugins.serveZoneInterfaces.data.coreMailLimits.desiredStateBytes);
+        const desiredState = await this.parseDesiredState(bytes, snapshot.configEpoch, snapshot.desiredStateDigest);
+        if (snapshot.state === 'staged') {
+            await this.models.DesiredSnapshot.exact.transition({
+                current: snapshot,
+                change: (modelArg) => {
+                    modelArg.state = 'active';
+                    modelArg.activatedAt = stateArg.updatedAt;
+                },
+            }).catch(async () => {
+                await logCoreMailFailure('desired-state', 'SNAPSHOT_REPAIR_FAILED')
+                    .catch(() => undefined);
+            });
+        }
+        return desiredState;
+    }
+    async parseDesiredState(bytesArg, configEpochArg, digestArg) {
+        let parsed;
+        try {
+            parsed = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytesArg));
+        }
+        catch {
+            throw new Error('CoreMail desired state is not canonical UTF-8 JSON.');
+        }
+        const desiredState = plugins.serveZoneInterfaces.data.normalizeCoreMailDesiredState(parsed);
+        if (desiredState.configEpoch !== configEpochArg
+            || !await plugins.serveZoneInterfaces.data.verifyCoreMailDesiredStateDigest(desiredState, digestArg)) {
+            throw new Error('CoreMail desired-state digest or epoch does not match.');
+        }
+        const canonical = plugins.serveZoneInterfaces.data.canonicalizeCoreMailDesiredState(desiredState);
+        if (!Buffer.from(bytesArg).equals(Buffer.from(canonical, 'utf8'))) {
+            throw new Error('CoreMail desired-state bytes are not canonical.');
+        }
+        return desiredState;
+    }
+    async prepare(requestArg) {
+        await this.refresh();
+        const desiredStateDigest = plugins.serveZoneInterfaces.data.normalizeCoreMailSha256(requestArg.desiredStateDigest);
+        const expectedAppliedConfigEpoch = requireCoreMailSafeInteger(requestArg.expectedAppliedConfigEpoch, 'expectedAppliedConfigEpoch');
+        const configEpoch = requireCoreMailSafeInteger(requestArg.configEpoch, 'configEpoch', 1);
+        if (configEpoch <= expectedAppliedConfigEpoch
+            || !Number.isSafeInteger(requestArg.lengthBytes)
+            || requestArg.lengthBytes < 2
+            || requestArg.lengthBytes >
+                plugins.serveZoneInterfaces.data.coreMailLimits.desiredStateBytes) {
+            throw new Error('CoreMail desired-state preparation is invalid.');
+        }
+        const current = await this.models.State.exact.findStoredOne({
+            stateId: 'active',
+            appliedConfigEpoch: expectedAppliedConfigEpoch,
+        });
+        if (!current || current.appliedConfigEpoch !== this.activeStatePointer.appliedConfigEpoch) {
+            throw new Error('CoreMail desired-state compare-and-set fence changed.');
+        }
+        let snapshot = await this.models.DesiredSnapshot.exact.findStoredOne({
+            configEpoch,
+            desiredStateDigest,
+        });
+        let replayed = Boolean(snapshot);
+        if (snapshot) {
+            if (snapshot.expectedAppliedConfigEpoch !== expectedAppliedConfigEpoch
+                || snapshot.lengthBytes !== requestArg.lengthBytes
+                || (snapshot.state !== 'staged' && snapshot.state !== 'active')) {
+                throw new Error('CoreMail desired-state replay conflicts with persisted intent.');
+            }
+        }
+        else {
+            const snapshotId = plugins.nodeCrypto.randomUUID();
+            const createdAt = this.now();
+            const candidate = {
+                snapshotId,
+                reconciliationId: plugins.nodeCrypto.randomUUID(),
+                expectedAppliedConfigEpoch,
+                configEpoch,
+                desiredStateDigest,
+                lengthBytes: requestArg.lengthBytes,
+                objectKey: `desired-state/${snapshotId}.json`,
+                state: 'staged',
+                createdAt,
+                updatedAt: createdAt,
+            };
+            try {
+                const inserted = await this.models.DesiredSnapshot.exact.insert(candidate);
+                if (inserted.status === 'conflict') {
+                    throw new Error('CoreMail desired-state preparation conflicts with persisted intent.');
+                }
+                snapshot = inserted.document;
+            }
+            catch (error) {
+                if (!(error instanceof plugins.smartdata.SmartdataExactPersistenceError)
+                    || error.code !== 'unique_conflict') {
+                    throw error;
+                }
+                const concurrent = await this.models.DesiredSnapshot.exact.findStoredOne({
+                    configEpoch,
+                    desiredStateDigest,
+                });
+                if (!concurrent
+                    || concurrent.expectedAppliedConfigEpoch
+                        !== expectedAppliedConfigEpoch
+                    || concurrent.lengthBytes !== requestArg.lengthBytes
+                    || (concurrent.state !== 'staged' && concurrent.state !== 'active')) {
+                    throw new Error('CoreMail desired-state preparation conflicts with persisted intent.');
+                }
+                snapshot = concurrent;
+                replayed = true;
+            }
+        }
+        if (snapshot.state === 'staged') {
+            const touchedAt = this.now();
+            const touch = await this.models.DesiredSnapshot.exact.transition({
+                current: snapshot,
+                change: (modelArg) => {
+                    modelArg.updatedAt = touchedAt;
+                },
+            });
+            if (touch.status !== 'transitioned') {
+                throw new Error('CoreMail desired-state preparation fence changed.');
+            }
+            snapshot = touch.document;
+        }
+        const grant = await this.transfers.issueGrant({
+            authority: this.controlAuthority(),
+            purpose: 'desired-state-upload',
+            method: 'PUT',
+            expectedSha256: snapshot.desiredStateDigest,
+            lengthBytes: snapshot.lengthBytes,
+            contentType: 'application/json',
+            objectKey: snapshot.objectKey,
+        });
+        return {
+            reconciliationId: snapshot.reconciliationId,
+            grant: grant,
+            replayed,
+        };
+    }
+    async apply(requestArg) {
+        await this.refresh();
+        const desiredStateDigest = plugins.serveZoneInterfaces.data.normalizeCoreMailSha256(requestArg.desiredStateDigest);
+        const reconciliationId = requireCoreMailUuid(requestArg.reconciliationId, 'reconciliationId');
+        const grantId = requireCoreMailUuid(requestArg.grantId, 'grantId');
+        const lengthBytes = requireCoreMailSafeInteger(requestArg.lengthBytes, 'lengthBytes', 2);
+        const snapshot = await this.models.DesiredSnapshot.exact.findStoredOne({
+            reconciliationId,
+            desiredStateDigest,
+            lengthBytes,
+        });
+        if (!snapshot || (snapshot.state !== 'staged' && snapshot.state !== 'active')) {
+            throw new Error('CoreMail desired-state reconciliation is unavailable.');
+        }
+        await this.transfers.assertConsumed({
+            grantId,
+            authority: this.controlAuthority(),
+            purpose: 'desired-state-upload',
+            expectedSha256: desiredStateDigest,
+            lengthBytes,
+            objectKey: snapshot.objectKey,
+        });
+        const bytes = await this.storage.getVerifiedBytes(snapshot.objectKey, snapshot.lengthBytes, snapshot.desiredStateDigest, plugins.serveZoneInterfaces.data.coreMailLimits.desiredStateBytes);
+        const desiredState = await this.parseDesiredState(bytes, snapshot.configEpoch, snapshot.desiredStateDigest);
+        if (snapshot.state === 'active'
+            && this.activeStatePointer.snapshotId === snapshot.snapshotId) {
+            return await this.createStatus('ready', desiredState);
+        }
+        const activatedAt = this.now();
+        const activation = await withCoreMailTransaction(this.database, async (transactionArg) => {
+            const transactionSnapshot = await this.models.DesiredSnapshot.exact.findStoredOne({
+                snapshotId: snapshot.snapshotId,
+                reconciliationId: snapshot.reconciliationId,
+                state: 'staged',
+            }, { session: transactionArg });
+            const current = await this.models.State.exact.findStoredOne({
+                stateId: 'active',
+                appliedConfigEpoch: snapshot.expectedAppliedConfigEpoch,
+            }, { session: transactionArg });
+            if (!transactionSnapshot
+                || !current
+                || snapshot.configEpoch <= current.appliedConfigEpoch
+                || current.snapshotId !== this.activeStatePointer.snapshotId
+                || current.appliedDesiredStateDigest
+                    !== this.activeStatePointer.appliedDesiredStateDigest) {
+                throw new Error('CoreMail desired-state anti-rollback fence changed.');
+            }
+            const snapshotActivation = await this.models.DesiredSnapshot.exact.transition({
+                current: transactionSnapshot,
+                change: (modelArg) => {
+                    modelArg.state = 'active';
+                    modelArg.activatedAt = activatedAt;
+                    modelArg.updatedAt = activatedAt;
+                },
+            }, { session: transactionArg });
+            if (snapshotActivation.status !== 'transitioned') {
+                throw new Error('CoreMail desired-state snapshot activation was contended.');
+            }
+            if (current.snapshotId !== '-') {
+                const prior = await this.models.DesiredSnapshot.exact.findStoredOne({
+                    snapshotId: current.snapshotId,
+                }, { session: transactionArg });
+                if (!prior) {
+                    throw new Error('CoreMail prior desired-state snapshot is unavailable.');
+                }
+                const superseded = await this.models.DesiredSnapshot.exact.transition({
+                    current: prior,
+                    change: (modelArg) => {
+                        modelArg.state = 'superseded';
+                        modelArg.activatedAt ??= current.updatedAt;
+                        modelArg.updatedAt = activatedAt;
+                    },
+                }, { session: transactionArg });
+                if (superseded.status !== 'transitioned') {
+                    throw new Error('CoreMail prior desired-state snapshot was contended.');
+                }
+            }
+            const pointerActivation = await this.models.State.exact.transition({
+                current,
+                change: (modelArg) => {
+                    modelArg.appliedConfigEpoch = snapshot.configEpoch;
+                    modelArg.appliedDesiredStateDigest = snapshot.desiredStateDigest;
+                    modelArg.snapshotId = snapshot.snapshotId;
+                    modelArg.updatedAt = activatedAt;
+                },
+            }, { session: transactionArg });
+            if (pointerActivation.status !== 'transitioned') {
+                throw new Error('CoreMail desired-state activation was contended.');
+            }
+            return pointerActivation.document;
+        });
+        this.activeStatePointer = activation;
+        this.activeDesiredState = desiredState;
+        return await this.createStatus('ready', desiredState);
+    }
+    async getStatus(requestArg) {
+        await this.refresh();
+        if (this.activeStatePointer.appliedConfigEpoch === 0) {
+            throw new Error('CoreMail has no applied desired state.');
+        }
+        const digest = plugins.serveZoneInterfaces.data.normalizeCoreMailSha256(requestArg.desiredStateDigest);
+        if (this.activeDesiredState?.configEpoch === requestArg.configEpoch
+            && this.activeStatePointer.appliedDesiredStateDigest === digest) {
+            return await this.createStatus('ready', this.activeDesiredState);
+        }
+        const snapshot = await this.models.DesiredSnapshot.exact.findStoredOne({
+            configEpoch: requestArg.configEpoch,
+            desiredStateDigest: digest,
+        });
+        return await this.createStatus(snapshot?.state === 'staged' ? 'applying' : 'failed', this.activeDesiredState, snapshot?.errorCode ?? 'RECONCILIATION_FENCE_MISMATCH');
+    }
+    async createStatus(stateArg, desiredStateArg, errorCodeArg) {
+        const bindings = await Promise.all((desiredStateArg?.bindings ?? []).map(async (bindingArg) => ({
+            bindingId: bindingArg.bindingId,
+            revision: bindingArg.revision,
+            state: bindingArg.state,
+            pendingInboundCount: await this.models.InboundDelivery.exact.count({
+                tenantId: bindingArg.tenantId,
+                serviceId: bindingArg.serviceId,
+                bindingId: bindingArg.bindingId,
+                bindingRevision: bindingArg.revision,
+                state: {
+                    $in: [...plugins.serveZoneInterfaces.data.coreMailQuotaPolicy
+                            .pendingInboundStates],
+                },
+            }),
+            activeSessionsByCredential: this.activeSessionCounts(bindingArg, desiredStateArg.configEpoch),
+        })));
+        return {
+            replica: { ...this.replica },
+            state: stateArg,
+            appliedConfigEpoch: this.activeStatePointer.appliedConfigEpoch,
+            appliedDesiredStateDigest: this.activeStatePointer.appliedDesiredStateDigest,
+            bindings,
+            updatedAt: this.now(),
+            ...(errorCodeArg ? { errorCode: errorCodeArg } : {}),
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.desiredstate.js","sourceRoot":"","sources":["../ts/classes.desiredstate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,cAAc,CAAC;AACxC,OAAO,EAAwB,MAAM,qBAAqB,CAAC;AAC3D,OAAO,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACrE,OAAO,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AAEhE,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AAK9D,OAAO,EACL,0BAA0B,EAC1B,mBAAmB,GACpB,MAAM,yBAAyB,CAAC;AASjC,MAAM,gBAAgB,GAAG,YAAY,CAAC,EAAE,CAAC,CAAC;AAE1C,MAAM,OAAO,2BAA2B;IAMnB;IACA;IACA;IACA;IACA;IACA;IAIA;IAdX,kBAAkB,GAAiC,IAAI,CAAC;IACxD,kBAAkB,CAAgB;IAClC,WAAW,GAAyB,IAAI,CAAC;IAEjD,YACmB,QAAuC,EACvC,MAAuB,EACvB,OAAwB,EACxB,SAAkC,EAClC,OAAgC,EAChC,mBAGmD,EACnD,MAAoB,IAAI,CAAC,GAAG;QAT5B,aAAQ,GAAR,QAAQ,CAA+B;QACvC,WAAM,GAAN,MAAM,CAAiB;QACvB,YAAO,GAAP,OAAO,CAAiB;QACxB,cAAS,GAAT,SAAS,CAAyB;QAClC,YAAO,GAAP,OAAO,CAAyB;QAChC,wBAAmB,GAAnB,mBAAmB,CAGgC;QACnD,QAAG,GAAH,GAAG,CAAyB;IAC5C,CAAC;IAEI,gBAAgB;QACtB,OAAO;YACL,IAAI,EAAE,SAAS;YACf,QAAQ,EAAE,GAAG;YACb,SAAS,EAAE,IAAI,CAAC,OAAO,CAAC,SAAS;YACjC,SAAS,EAAE,GAAG;SACf,CAAC;IACJ,CAAC;IAEM,KAAK,CAAC,KAAK;QAChB,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC;YACvD,OAAO,EAAE,QAAQ;YACjB,kBAAkB,EAAE,CAAC;YACrB,yBAAyB,EAAE,gBAAgB;YAC3C,UAAU,EAAE,GAAG;YACf,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE;SACtB,CAAC,CAAC;QACH,MAAM,KAAK,GAAG,WAAW,CAAC,QAAQ,CAAC;QACnC,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,MAAM,IAAI,KAAK,CAAC,0DAA0D,CAAC,CAAC;QAC9E,CAAC;QACD,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC;QAChC,MAAM,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC;IACvC,CAAC;IAEM,qBAAqB,GAAG,KAAK,IAA2C,EAAE;QAC/E,MAAM,IAAI,CAAC,OAAO,EAAE,CAAC;QACrB,OAAO,IAAI,CAAC,kBAAkB,CAAC;IACjC,CAAC,CAAC;IAEM,KAAK,CAAC,OAAO;QACnB,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC;YACrB,MAAM,IAAI,CAAC,WAAW,CAAC;YACvB,OAAO;QACT,CAAC;QACD,MAAM,IAAI,GAAG,CAAC,KAAK,IAAI,EAAE;YACvB,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,aAAa,CAAC;gBAC1D,OAAO,EAAE,QAAQ;aAClB,CAAC,CAAC;YACH,IAAI,CAAC,OAAO,EAAE,CAAC;gBACb,MAAM,IAAI,KAAK,CAAC,gDAAgD,CAAC,CAAC;YACpE,CAAC;YACD,MAAM,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC;QACzC,CAAC,CAAC,EAAE,CAAC;QACL,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;QACxB,IAAI,CAAC;YACH,MAAM,IAAI,CAAC;QACb,CAAC;gBAAS,CAAC;YACT,IAAI,IAAI,CAAC,WAAW,KAAK,IAAI,EAAE,CAAC;gBAC9B,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;YAC1B,CAAC;QACH,CAAC;IACH,CAAC;IAEO,KAAK,CAAC,kBAAkB,CAAC,UAAwB;QACvD,IAAI,UAAU,CAAC,kBAAkB,KAAK,CAAC,EAAE,CAAC;YACxC,IAAI,CAAC,kBAAkB,GAAG,UAAU,CAAC;YACrC,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC;YAC/B,OAAO;QACT,CAAC;QACD,IACE,IAAI,CAAC,kBAAkB,EAAE,WAAW,KAAK,UAAU,CAAC,kBAAkB;eACnE,IAAI,CAAC,kBAAkB,EAAE,UAAU,KAAK,UAAU,CAAC,UAAU;eAC7D,IAAI,CAAC,kBAAkB,CAAC,yBAAyB;oBAC9C,UAAU,CAAC,yBAAyB,EAC1C,CAAC;YACD,IAAI,CAAC,kBAAkB,GAAG,UAAU,CAAC;YACrC,OAAO;QACT,CAAC;QACD,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,gBAAgB,CAAC,UAAU,CAAC,CAAC;QAC7D,IAAI,CAAC,kBAAkB,GAAG,UAAU,CAAC;QACrC,IAAI,CAAC,kBAAkB,GAAG,YAAY,CAAC;IACzC,CAAC;IAEO,KAAK,CAAC,gBAAgB,CAAC,QAAsB;QACnD,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,KAAK,CAAC,aAAa,CAAC;YACrE,UAAU,EAAE,QAAQ,CAAC,UAAU;YAC/B,WAAW,EAAE,QAAQ,CAAC,kBAAkB;YACxC,kBAAkB,EAAE,QAAQ,CAAC,yBAAyB;SACvD,CAAC,CAAC;QACH,IACE,CAAC,QAAQ;eACN,CAAC,QAAQ,CAAC,KAAK,KAAK,QAAQ,IAAI,QAAQ,CAAC,KAAK,KAAK,QAAQ,CAAC,EAC/D,CAAC;YACD,MAAM,IAAI,KAAK,CAAC,wDAAwD,CAAC,CAAC;QAC5E,CAAC;QACD,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,gBAAgB,CAC/C,QAAQ,CAAC,SAAS,EAClB,QAAQ,CAAC,WAAW,EACpB,QAAQ,CAAC,kBAAkB,EAC3B,OAAO,CAAC,mBAAmB,CAAC,IAAI,CAAC,cAAc,CAAC,iBAAiB,CAClE,CAAC;QACF,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,iBAAiB,CAC/C,KAAK,EACL,QAAQ,CAAC,WAAW,EACpB,QAAQ,CAAC,kBAAkB,CAC5B,CAAC;QACF,IAAI,QAAQ,CAAC,KAAK,KAAK,QAAQ,EAAE,CAAC;YAChC,MAAM,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,KAAK,CAAC,UAAU,CAAC;gBACjD,OAAO,EAAE,QAAQ;gBACjB,MAAM,EAAE,CAAC,QAAQ,EAAE,EAAE;oBACnB,QAAQ,CAAC,KAAK,GAAG,QAAQ,CAAC;oBAC1B,QAAQ,CAAC,WAAW,GAAG,QAAQ,CAAC,SAAS,CAAC;gBAC5C,CAAC;aACF,CAAC,CAAC,KAAK,CAAC,KAAK,IAAI,EAAE;gBAClB,MAAM,kBAAkB,CAAC,eAAe,EAAE,wBAAwB,CAAC;qBAChE,KAAK,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;YAC5B,CAAC,CAAC,CAAC;QACL,CAAC;QACD,OAAO,YAAY,CAAC;IACtB,CAAC;IAEO,KAAK,CAAC,iBAAiB,CAC7B,QAAoB,EACpB,cAAsB,EACtB,SAA0B;QAE1B,IAAI,MAAe,CAAC;QACpB,IAAI,CAAC;YACH,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,WAAW,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;QAClF,CAAC;QAAC,MAAM,CAAC;YACP,MAAM,IAAI,KAAK,CAAC,qDAAqD,CAAC,CAAC;QACzE,CAAC;QACD,MAAM,YAAY,GAChB,OAAO,CAAC,mBAAmB,CAAC,IAAI,CAAC,6BAA6B,CAAC,MAAM,CAAC,CAAC;QACzE,IACE,YAAY,CAAC,WAAW,KAAK,cAAc;eACxC,CAAC,MAAM,OAAO,CAAC,mBAAmB,CAAC,IAAI,CAAC,gCAAgC,CACzE,YAAY,EACZ,SAAS,CACV,EACD,CAAC;YACD,MAAM,IAAI,KAAK,CAAC,wDAAwD,CAAC,CAAC;QAC5E,CAAC;QACD,MAAM,SAAS,GAAG,OAAO,CAAC,mBAAmB,CAAC,IAAI,CAAC,gCAAgC,CACjF,YAAY,CACb,CAAC;QACF,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC,EAAE,CAAC;YAClE,MAAM,IAAI,KAAK,CAAC,iDAAiD,CAAC,CAAC;QACrE,CAAC;QACD,OAAO,YAAY,CAAC;IACtB,CAAC;IAEM,KAAK,CAAC,OAAO,CAClB,UACiG;QAMjG,MAAM,IAAI,CAAC,OAAO,EAAE,CAAC;QACrB,MAAM,kBAAkB,GACtB,OAAO,CAAC,mBAAmB,CAAC,IAAI,CAAC,uBAAuB,CACtD,UAAU,CAAC,kBAAkB,CAC9B,CAAC;QACJ,MAAM,0BAA0B,GAAG,0BAA0B,CAC3D,UAAU,CAAC,0BAA0B,EACrC,4BAA4B,CAC7B,CAAC;QACF,MAAM,WAAW,GAAG,0BAA0B,CAC5C,UAAU,CAAC,WAAW,EACtB,aAAa,EACb,CAAC,CACF,CAAC;QACF,IACE,WAAW,IAAI,0BAA0B;eACtC,CAAC,MAAM,CAAC,aAAa,CAAC,UAAU,CAAC,WAAW,CAAC;eAC7C,UAAU,CAAC,WAAW,GAAG,CAAC;eAC1B,UAAU,CAAC,WAAW;gBACvB,OAAO,CAAC,mBAAmB,CAAC,IAAI,CAAC,cAAc,CAAC,iBAAiB,EACnE,CAAC;YACD,MAAM,IAAI,KAAK,CAAC,gDAAgD,CAAC,CAAC;QACpE,CAAC;QACD,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,aAAa,CAAC;YAC1D,OAAO,EAAE,QAAQ;YACjB,kBAAkB,EAAE,0BAA0B;SAC/C,CAAC,CAAC;QACH,IAAI,CAAC,OAAO,IAAI,OAAO,CAAC,kBAAkB,KAAK,IAAI,CAAC,kBAAkB,CAAC,kBAAkB,EAAE,CAAC;YAC1F,MAAM,IAAI,KAAK,CAAC,uDAAuD,CAAC,CAAC;QAC3E,CAAC;QACD,IAAI,QAAQ,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,KAAK,CAAC,aAAa,CAAC;YACnE,WAAW;YACX,kBAAkB;SACnB,CAAC,CAAC;QACH,IAAI,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;QACjC,IAAI,QAAQ,EAAE,CAAC;YACb,IACE,QAAQ,CAAC,0BAA0B,KAAK,0BAA0B;mBAC/D,QAAQ,CAAC,WAAW,KAAK,UAAU,CAAC,WAAW;mBAC/C,CAAC,QAAQ,CAAC,KAAK,KAAK,QAAQ,IAAI,QAAQ,CAAC,KAAK,KAAK,QAAQ,CAAC,EAC/D,CAAC;gBACD,MAAM,IAAI,KAAK,CAAC,gEAAgE,CAAC,CAAC;YACpF,CAAC;QACH,CAAC;aAAM,CAAC;YACN,MAAM,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,UAAU,EAAE,CAAC;YACnD,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;YAC7B,MAAM,SAAS,GAAmC;gBAChD,UAAU;gBACV,gBAAgB,EAAE,OAAO,CAAC,UAAU,CAAC,UAAU,EAAE;gBACjD,0BAA0B;gBAC1B,WAAW;gBACX,kBAAkB;gBAClB,WAAW,EAAE,UAAU,CAAC,WAAW;gBACnC,SAAS,EAAE,iBAAiB,UAAU,OAAO;gBAC7C,KAAK,EAAE,QAAQ;gBACf,SAAS;gBACT,SAAS,EAAE,SAAS;aACrB,CAAC;YACF,IAAI,CAAC;gBACH,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,KAAK,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;gBAC3E,IAAI,QAAQ,CAAC,MAAM,KAAK,UAAU,EAAE,CAAC;oBACnC,MAAM,IAAI,KAAK,CACb,qEAAqE,CACtE,CAAC;gBACJ,CAAC;gBACD,QAAQ,GAAG,QAAQ,CAAC,QAAQ,CAAC;YAC/B,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,IACE,CAAC,CAAC,KAAK,YAAY,OAAO,CAAC,SAAS,CAAC,8BAA8B,CAAC;uBACjE,KAAK,CAAC,IAAI,KAAK,iBAAiB,EACnC,CAAC;oBACD,MAAM,KAAK,CAAC;gBACd,CAAC;gBACD,MAAM,UAAU,GACd,MAAM,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,KAAK,CAAC,aAAa,CAAC;oBACtD,WAAW;oBACX,kBAAkB;iBACnB,CAAC,CAAC;gBACH,IACE,CAAC,UAAU;uBACR,UAAU,CAAC,0BAA0B;4BAClC,0BAA0B;uBAC7B,UAAU,CAAC,WAAW,KAAK,UAAU,CAAC,WAAW;uBACjD,CAAC,UAAU,CAAC,KAAK,KAAK,QAAQ,IAAI,UAAU,CAAC,KAAK,KAAK,QAAQ,CAAC,EACnE,CAAC;oBACD,MAAM,IAAI,KAAK,CACb,qEAAqE,CACtE,CAAC;gBACJ,CAAC;gBACD,QAAQ,GAAG,UAAU,CAAC;gBACtB,QAAQ,GAAG,IAAI,CAAC;YAClB,CAAC;QACH,CAAC;QACD,IAAI,QAAQ,CAAC,KAAK,KAAK,QAAQ,EAAE,CAAC;YAChC,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;YAC7B,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,KAAK,CAAC,UAAU,CAAC;gBAC/D,OAAO,EAAE,QAAQ;gBACjB,MAAM,EAAE,CAAC,QAAQ,EAAE,EAAE;oBACnB,QAAQ,CAAC,SAAS,GAAG,SAAS,CAAC;gBACjC,CAAC;aACF,CAAC,CAAC;YACH,IAAI,KAAK,CAAC,MAAM,KAAK,cAAc,EAAE,CAAC;gBACpC,MAAM,IAAI,KAAK,CAAC,mDAAmD,CAAC,CAAC;YACvE,CAAC;YACD,QAAQ,GAAG,KAAK,CAAC,QAAQ,CAAC;QAC5B,CAAC;QACD,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC;YAC5C,SAAS,EAAE,IAAI,CAAC,gBAAgB,EAAE;YAClC,OAAO,EAAE,sBAAsB;YAC/B,MAAM,EAAE,KAAK;YACb,cAAc,EAAE,QAAQ,CAAC,kBAAkB;YAC3C,WAAW,EAAE,QAAQ,CAAC,WAAW;YACjC,WAAW,EAAE,kBAAkB;YAC/B,SAAS,EAAE,QAAQ,CAAC,SAAS;SAC9B,CAAC,CAAC;QACH,OAAO;YACL,gBAAgB,EAAE,QAAQ,CAAC,gBAAgB;YAC3C,KAAK,EAAE,KAA8D;YACrE,QAAQ;SACT,CAAC;IACJ,CAAC;IAEM,KAAK,CAAC,KAAK,CAChB,UACyF;QAEzF,MAAM,IAAI,CAAC,OAAO,EAAE,CAAC;QACrB,MAAM,kBAAkB,GACtB,OAAO,CAAC,mBAAmB,CAAC,IAAI,CAAC,uBAAuB,CACtD,UAAU,CAAC,kBAAkB,CAC9B,CAAC;QACJ,MAAM,gBAAgB,GAAG,mBAAmB,CAC1C,UAAU,CAAC,gBAAgB,EAC3B,kBAAkB,CACnB,CAAC;QACF,MAAM,OAAO,GAAG,mBAAmB,CAAC,UAAU,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;QACnE,MAAM,WAAW,GAAG,0BAA0B,CAC5C,UAAU,CAAC,WAAW,EACtB,aAAa,EACb,CAAC,CACF,CAAC;QACF,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,KAAK,CAAC,aAAa,CAAC;YACrE,gBAAgB;YAChB,kBAAkB;YAClB,WAAW;SACZ,CAAC,CAAC;QACH,IAAI,CAAC,QAAQ,IAAI,CAAC,QAAQ,CAAC,KAAK,KAAK,QAAQ,IAAI,QAAQ,CAAC,KAAK,KAAK,QAAQ,CAAC,EAAE,CAAC;YAC9E,MAAM,IAAI,KAAK,CAAC,uDAAuD,CAAC,CAAC;QAC3E,CAAC;QACD,MAAM,IAAI,CAAC,SAAS,CAAC,cAAc,CAAC;YAClC,OAAO;YACP,SAAS,EAAE,IAAI,CAAC,gBAAgB,EAAE;YAClC,OAAO,EAAE,sBAAsB;YAC/B,cAAc,EAAE,kBAAkB;YAClC,WAAW;YACX,SAAS,EAAE,QAAQ,CAAC,SAAS;SAC9B,CAAC,CAAC;QACH,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,gBAAgB,CAC/C,QAAQ,CAAC,SAAS,EAClB,QAAQ,CAAC,WAAW,EACpB,QAAQ,CAAC,kBAAkB,EAC3B,OAAO,CAAC,mBAAmB,CAAC,IAAI,CAAC,cAAc,CAAC,iBAAiB,CAClE,CAAC;QACF,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,iBAAiB,CAC/C,KAAK,EACL,QAAQ,CAAC,WAAW,EACpB,QAAQ,CAAC,kBAAkB,CAC5B,CAAC;QACF,IACE,QAAQ,CAAC,KAAK,KAAK,QAAQ;eACxB,IAAI,CAAC,kBAAkB,CAAC,UAAU,KAAK,QAAQ,CAAC,UAAU,EAC7D,CAAC;YACD,OAAO,MAAM,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC;QACxD,CAAC;QACD,MAAM,WAAW,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAC/B,MAAM,UAAU,GAAG,MAAM,uBAAuB,CAC9C,IAAI,CAAC,QAAQ,EACb,KAAK,EAAE,cAAc,EAAE,EAAE;YACvB,MAAM,mBAAmB,GACvB,MAAM,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,KAAK,CAAC,aAAa,CAAC;gBACpD,UAAU,EAAE,QAAQ,CAAC,UAAU;gBAC/B,gBAAgB,EAAE,QAAQ,CAAC,gBAAgB;gBAC3C,KAAK,EAAE,QAAQ;aAChB,EAAE,EAAE,OAAO,EAAE,cAAc,EAAE,CAAC,CAAC;YAClC,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,aAAa,CAAC;gBAC1D,OAAO,EAAE,QAAQ;gBACjB,kBAAkB,EAAE,QAAQ,CAAC,0BAA0B;aACxD,EAAE,EAAE,OAAO,EAAE,cAAc,EAAE,CAAC,CAAC;YAChC,IACE,CAAC,mBAAmB;mBACjB,CAAC,OAAO;mBACR,QAAQ,CAAC,WAAW,IAAI,OAAO,CAAC,kBAAkB;mBAClD,OAAO,CAAC,UAAU,KAAK,IAAI,CAAC,kBAAkB,CAAC,UAAU;mBACzD,OAAO,CAAC,yBAAyB;wBAC9B,IAAI,CAAC,kBAAkB,CAAC,yBAAyB,EACvD,CAAC;gBACD,MAAM,IAAI,KAAK,CAAC,qDAAqD,CAAC,CAAC;YACzE,CAAC;YACD,MAAM,kBAAkB,GACtB,MAAM,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,KAAK,CAAC,UAAU,CAAC;gBACjD,OAAO,EAAE,mBAAmB;gBAC5B,MAAM,EAAE,CAAC,QAAQ,EAAE,EAAE;oBACnB,QAAQ,CAAC,KAAK,GAAG,QAAQ,CAAC;oBAC1B,QAAQ,CAAC,WAAW,GAAG,WAAW,CAAC;oBACnC,QAAQ,CAAC,SAAS,GAAG,WAAW,CAAC;gBACnC,CAAC;aACF,EAAE,EAAE,OAAO,EAAE,cAAc,EAAE,CAAC,CAAC;YAClC,IAAI,kBAAkB,CAAC,MAAM,KAAK,cAAc,EAAE,CAAC;gBACjD,MAAM,IAAI,KAAK,CAAC,2DAA2D,CAAC,CAAC;YAC/E,CAAC;YACD,IAAI,OAAO,CAAC,UAAU,KAAK,GAAG,EAAE,CAAC;gBAC/B,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,KAAK,CAAC,aAAa,CAAC;oBAClE,UAAU,EAAE,OAAO,CAAC,UAAU;iBAC/B,EAAE,EAAE,OAAO,EAAE,cAAc,EAAE,CAAC,CAAC;gBAChC,IAAI,CAAC,KAAK,EAAE,CAAC;oBACX,MAAM,IAAI,KAAK,CAAC,uDAAuD,CAAC,CAAC;gBAC3E,CAAC;gBACD,MAAM,UAAU,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,KAAK,CAAC,UAAU,CAAC;oBACpE,OAAO,EAAE,KAAK;oBACd,MAAM,EAAE,CAAC,QAAQ,EAAE,EAAE;wBACnB,QAAQ,CAAC,KAAK,GAAG,YAAY,CAAC;wBAC9B,QAAQ,CAAC,WAAW,KAAK,OAAO,CAAC,SAAS,CAAC;wBAC3C,QAAQ,CAAC,SAAS,GAAG,WAAW,CAAC;oBACnC,CAAC;iBACF,EAAE,EAAE,OAAO,EAAE,cAAc,EAAE,CAAC,CAAC;gBAChC,IAAI,UAAU,CAAC,MAAM,KAAK,cAAc,EAAE,CAAC;oBACzC,MAAM,IAAI,KAAK,CAAC,sDAAsD,CAAC,CAAC;gBAC1E,CAAC;YACH,CAAC;YACD,MAAM,iBAAiB,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,UAAU,CAAC;gBACjE,OAAO;gBACP,MAAM,EAAE,CAAC,QAAQ,EAAE,EAAE;oBACnB,QAAQ,CAAC,kBAAkB,GAAG,QAAQ,CAAC,WAAW,CAAC;oBACnD,QAAQ,CAAC,yBAAyB,GAAG,QAAQ,CAAC,kBAAkB,CAAC;oBACjE,QAAQ,CAAC,UAAU,GAAG,QAAQ,CAAC,UAAU,CAAC;oBAC1C,QAAQ,CAAC,SAAS,GAAG,WAAW,CAAC;gBACnC,CAAC;aACF,EAAE,EAAE,OAAO,EAAE,cAAc,EAAE,CAAC,CAAC;YAChC,IAAI,iBAAiB,CAAC,MAAM,KAAK,cAAc,EAAE,CAAC;gBAChD,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC,CAAC;YACtE,CAAC;YACD,OAAO,iBAAiB,CAAC,QAAQ,CAAC;QACpC,CAAC,CACF,CAAC;QACF,IAAI,CAAC,kBAAkB,GAAG,UAAU,CAAC;QACrC,IAAI,CAAC,kBAAkB,GAAG,YAAY,CAAC;QACvC,OAAO,MAAM,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC;IACxD,CAAC;IAEM,KAAK,CAAC,SAAS,CACpB,UAC+F;QAE/F,MAAM,IAAI,CAAC,OAAO,EAAE,CAAC;QACrB,IAAI,IAAI,CAAC,kBAAkB,CAAC,kBAAkB,KAAK,CAAC,EAAE,CAAC;YACrD,MAAM,IAAI,KAAK,CAAC,wCAAwC,CAAC,CAAC;QAC5D,CAAC;QACD,MAAM,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC,IAAI,CAAC,uBAAuB,CACrE,UAAU,CAAC,kBAAkB,CAC9B,CAAC;QACF,IACE,IAAI,CAAC,kBAAkB,EAAE,WAAW,KAAK,UAAU,CAAC,WAAW;eAC5D,IAAI,CAAC,kBAAkB,CAAC,yBAAyB,KAAK,MAAM,EAC/D,CAAC;YACD,OAAO,MAAM,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE,IAAI,CAAC,kBAAkB,CAAC,CAAC;QACnE,CAAC;QACD,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,KAAK,CAAC,aAAa,CAAC;YACrE,WAAW,EAAE,UAAU,CAAC,WAAW;YACnC,kBAAkB,EAAE,MAAM;SAC3B,CAAC,CAAC;QACH,OAAO,MAAM,IAAI,CAAC,YAAY,CAC5B,QAAQ,EAAE,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,QAAQ,EACpD,IAAI,CAAC,kBAAkB,EACvB,QAAQ,EAAE,SAAS,IAAI,+BAA+B,CACvD,CAAC;IACJ,CAAC;IAEO,KAAK,CAAC,YAAY,CACxB,QAAuE,EACvE,eAA6C,EAC7C,YAAkE;QAElE,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,GAAG,CAChC,CAAC,eAAe,EAAE,QAAQ,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,KAAK,EAAE,UAAU,EAAE,EAAE,CAAC,CAAC;YAC3D,SAAS,EAAE,UAAU,CAAC,SAAS;YAC/B,QAAQ,EAAE,UAAU,CAAC,QAAQ;YAC7B,KAAK,EAAE,UAAU,CAAC,KAAK;YACvB,mBAAmB,EAAE,MAAM,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,KAAK,CAAC,KAAK,CAAC;gBACjE,QAAQ,EAAE,UAAU,CAAC,QAAQ;gBAC7B,SAAS,EAAE,UAAU,CAAC,SAAS;gBAC/B,SAAS,EAAE,UAAU,CAAC,SAAS;gBAC/B,eAAe,EAAE,UAAU,CAAC,QAAQ;gBACpC,KAAK,EAAE;oBACL,GAAG,EAAE,CAAC,GAAG,OAAO,CAAC,mBAAmB,CAAC,IAAI,CAAC,mBAAmB;6BAC1D,oBAAoB,CAAC;iBACzB;aACF,CAAC;YACF,0BAA0B,EAAE,IAAI,CAAC,mBAAmB,CAClD,UAAU,EACV,eAAgB,CAAC,WAAW,CAC7B;SACF,CAAC,CAAC,CACJ,CAAC;QACF,OAAO;YACL,OAAO,EAAE,EAAE,GAAG,IAAI,CAAC,OAAO,EAAE;YAC5B,KAAK,EAAE,QAAQ;YACf,kBAAkB,EAAE,IAAI,CAAC,kBAAkB,CAAC,kBAAkB;YAC9D,yBAAyB,EAAE,IAAI,CAAC,kBAAkB,CAAC,yBAAyB;YAC5E,QAAQ;YACR,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE;YACrB,GAAG,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,YAAY,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;SACrD,CAAC;IACJ,CAAC;CACF"}

package/dist_ts/classes.gateway.d.ts

@@ -0,0 +1,62 @@
+import * as plugins from './plugins.js';
+import { type ICoreMailModels } from './classes.models.js';
+import { CoreMailTransferService } from './classes.transfer.js';
+import type { CoreMailInboundService } from './classes.inbound.js';
+import type { ICoreMailConfig } from './interfaces.js';
+import type { ICoreMailSubmissionRecord } from './coremail.persistence.js';
+type TDesiredState = plugins.serveZoneInterfaces.data.ICoreMailDesiredState;
+type TGatewayStatus = plugins.serveZoneInterfaces.data.ICoreMailGatewayOutboundStatus;
+type TStoredSubmission = plugins.smartdata.TStoredDocument<ICoreMailSubmissionRecord>;
+export declare const requireMatchingCoreMailTransferOrigin: (valueArg: unknown, expectedArg: string) => string;
+export declare class CoreMailGateway {
+    private readonly config;
+    private readonly models;
+    private readonly transfers;
+    private readonly inbound;
+    private readonly getDesiredState;
+    private readonly now;
+    private socket;
+    private socketSignature;
+    private authenticatedSignature;
+    private transferOrigin;
+    private readonly stopController;
+    private reconcileTask;
+    private statusSubscription;
+    private authenticationTask;
+    private authenticatingSignature;
+    constructor(config: ICoreMailConfig, models: ICoreMailModels, transfers: CoreMailTransferService, inbound: CoreMailInboundService, getDesiredState: () => Promise<TDesiredState | null>, now?: () => number);
+    start(): void;
+    stop(): Promise<void>;
+    isReady(): boolean;
+    getTransferOrigin(): string | null;
+    private runReconciliationLoop;
+    private connect;
+    private queueAuthentication;
+    private requireAuthenticated;
+    private disconnect;
+    prepareOutbound(submissionArg: ICoreMailSubmissionRecord, grantArg: plugins.serveZoneInterfaces.data.ICoreMailDownloadGrant): Promise<{
+        transportMessageId: string;
+        status: TGatewayStatus;
+        replayed: boolean;
+    }>;
+    getOutboundStatus(transportMessageIdArg: string): Promise<TGatewayStatus>;
+    private completeOutboundHandoff;
+    persistStatus(initialSubmissionArg: TStoredSubmission, statusArg: TGatewayStatus, leaseTokenArg?: string): Promise<TStoredSubmission>;
+}
+export declare class CoreMailOutboundWorker {
+    private readonly models;
+    private readonly transfers;
+    private readonly gateway;
+    private readonly replicaTaskId;
+    private readonly serviceId;
+    private readonly now;
+    private readonly stopController;
+    private workerTask;
+    constructor(models: ICoreMailModels, transfers: CoreMailTransferService, gateway: CoreMailGateway, replicaTaskId: string, serviceId: string, now?: () => number);
+    start(): void;
+    stop(): Promise<void>;
+    private run;
+    private processBatch;
+    private processClaimed;
+}
+export {};