@smarthome.exchange/integrations 0.2.0 → 2.0.0

package/dist_ts/core/classes.configstore.js

@@ -1,39 +1,362 @@
 import * as plugins from '../plugins.js';
-export class JsonFileConfigStore {
-    filePath;
-    constructor(filePath) {
-        this.filePath = filePath;
-    }
-    async get(keyArg) {
-        const data = await this.readFile();
-        return data[keyArg];
-    }
-    async set(keyArg, valueArg) {
-        const data = await this.readFile();
-        data[keyArg] = valueArg;
-        await this.writeFile(data);
-    }
-    async delete(keyArg) {
-        const data = await this.readFile();
-        delete data[keyArg];
-        await this.writeFile(data);
-    }
-    async list(prefixArg = '') {
-        const data = await this.readFile();
-        return Object.keys(data).filter((keyArg) => keyArg.startsWith(prefixArg));
-    }
-    async readFile() {
+import { IntegrationConfigRecord } from './classes.configrecord.js';
+const validateName = (valueArg, nameArg, maxLengthArg) => {
+    if (typeof valueArg !== 'string' || valueArg.length === 0 || valueArg.length > maxLengthArg || /[\p{Cc}\p{Cs}]/u.test(valueArg)) {
+        throw new TypeError(`${nameArg} must be a non-empty string without control characters, at most ${maxLengthArg} characters.`);
+    }
+    return valueArg;
+};
+const boundedInteger = (valueArg, nameArg, maximumArg) => {
+    if (!Number.isSafeInteger(valueArg) || valueArg < 1 || valueArg > maximumArg) {
+        throw new RangeError(`${nameArg} must be an integer from 1 through ${maximumArg}.`);
+    }
+    return valueArg;
+};
+const assertJsonValue = (valueArg, ancestorsArg = new Set(), depthArg = 0) => {
+    if (valueArg === null || typeof valueArg === 'string' || typeof valueArg === 'boolean')
+        return;
+    if (typeof valueArg === 'number' && Number.isFinite(valueArg))
+        return;
+    if (typeof valueArg !== 'object' || depthArg >= 32 || ancestorsArg.has(valueArg)) {
+        throw new TypeError('Config values must be finite JSON data without cycles and at most 32 levels deep.');
+    }
+    if (!Array.isArray(valueArg) && Object.getPrototypeOf(valueArg) !== Object.prototype && Object.getPrototypeOf(valueArg) !== null) {
+        throw new TypeError('Config values must contain only arrays and plain objects.');
+    }
+    ancestorsArg.add(valueArg);
+    try {
+        for (const key of Reflect.ownKeys(valueArg)) {
+            if (Array.isArray(valueArg) && key === 'length')
+                continue;
+            const descriptor = Object.getOwnPropertyDescriptor(valueArg, key);
+            if (typeof key !== 'string' || !descriptor || !('value' in descriptor) || !descriptor.enumerable) {
+                throw new TypeError('Config values may not contain symbols, accessors or hidden fields.');
+            }
+            if (Array.isArray(valueArg) && (!/^(0|[1-9]\d*)$/.test(key) || Number(key) >= valueArg.length)) {
+                throw new TypeError('Config arrays may not have additional properties.');
+            }
+            if (!Array.isArray(valueArg) && descriptor.value === undefined)
+                continue;
+            assertJsonValue(descriptor.value, ancestorsArg, depthArg + 1);
+        }
+        if (Array.isArray(valueArg) && Object.keys(valueArg).length !== valueArg.length) {
+            throw new TypeError('Config arrays must be dense and may not have additional properties.');
+        }
+    }
+    finally {
+        ancestorsArg.delete(valueArg);
+    }
+};
+const copyKey = (valueArg) => {
+    if (!(valueArg instanceof Uint8Array) || valueArg.byteLength !== 32) {
+        throw new TypeError('Config encryption requires an external 32-byte key.');
+    }
+    return Buffer.from(valueArg);
+};
+const decodeBase64 = (valueArg, maximumBytesArg, exactBytesArg) => {
+    if (typeof valueArg !== 'string' || valueArg.length > Math.ceil(maximumBytesArg / 3) * 4) {
+        throw new Error('Stored config encryption envelope is invalid.');
+    }
+    const decoded = Buffer.from(valueArg, 'base64');
+    if (decoded.toString('base64') !== valueArg || decoded.byteLength > maximumBytesArg || (exactBytesArg !== undefined && decoded.byteLength !== exactBytesArg)) {
+        throw new Error('Stored config encryption envelope is invalid.');
+    }
+    return decoded;
+};
+/** The caller owns the database and key provider; this store owns neither resource. */
+export class NoSqlConfigStore {
+    #records;
+    #homeId;
+    #integrationDomain;
+    #keyProvider;
+    #timeoutMs;
+    #maxPendingOperations;
+    #maxValueBytes;
+    #lifetime = new AbortController();
+    #preparations = new Set();
+    #keyLookups = new Set();
+    #retainedOperations = new Set();
+    #keyProviderFailures = new Set();
+    #operationTail = Promise.resolve();
+    #pendingOperations = 0;
+    #closePromise;
+    #retryPromise;
+    constructor(optionsArg) {
+        this.#homeId = validateName(optionsArg.homeId, 'homeId', 256);
+        this.#integrationDomain = validateName(optionsArg.integrationDomain, 'integrationDomain', 128);
+        this.#keyProvider = optionsArg.keyProvider;
+        this.#timeoutMs = boundedInteger(optionsArg.timeoutMs ?? 5000, 'timeoutMs', 120000);
+        this.#maxPendingOperations = boundedInteger(optionsArg.maxPendingOperations ?? 1000, 'maxPendingOperations', 10000);
+        this.#maxValueBytes = boundedInteger(optionsArg.maxValueBytes ?? 65536, 'maxValueBytes', 1048576);
+        if (!this.#keyProvider || typeof this.#keyProvider.currentKey !== 'function' || typeof this.#keyProvider.keyForId !== 'function') {
+            throw new TypeError('Config encryption requires a currentKey/keyForId provider.');
+        }
+        this.#records = plugins.nosqldb.bindDocToManager({ db: optionsArg.db }, IntegrationConfigRecord);
+    }
+    getScope() {
+        return Object.freeze({ homeId: this.#homeId, integrationDomain: this.#integrationDomain });
+    }
+    async initialize(optionsArg = {}) {
+        this.#assertOpen();
+        if (!optionsArg || Object.getPrototypeOf(optionsArg) !== Object.prototype ||
+            Reflect.ownKeys(optionsArg).some((keyArg) => keyArg !== 'signal' ||
+                !('value' in Object.getOwnPropertyDescriptor(optionsArg, keyArg)))) {
+            throw new TypeError('Config initialization options accept only an AbortSignal.');
+        }
+        const signal = Object.getOwnPropertyDescriptor(optionsArg, 'signal')?.value;
+        if (signal !== undefined && !(signal instanceof AbortSignal)) {
+            throw new TypeError('Config initialization signal must be an AbortSignal.');
+        }
+        signal?.throwIfAborted();
+        const preparation = this.#records.prepareCollection({
+            mode: 'ensureCompatible',
+            timeoutMs: this.#timeoutMs,
+            signal: signal ? AbortSignal.any([signal, this.#lifetime.signal]) : this.#lifetime.signal,
+        });
+        this.#preparations.add(preparation);
         try {
-            const fileString = await plugins.fs.readFile(this.filePath, 'utf8');
-            return JSON.parse(fileString);
+            await preparation;
+            this.#assertOpen();
+        }
+        finally {
+            this.#preparations.delete(preparation);
+        }
+    }
+    /** Stops this store without closing its caller-owned database or sessions. */
+    close() {
+        if (!this.#closePromise) {
+            this.#closePromise = Promise.resolve().then(async () => {
+                await Promise.allSettled([
+                    ...this.#preparations,
+                    this.#operationTail,
+                    ...this.#keyLookups,
+                ]);
+                if (this.#keyProviderFailures.size) {
+                    throw new AggregateError([...this.#keyProviderFailures], 'NoSqlConfigStore key-provider cleanup failed.');
+                }
+            });
+            this.#lifetime.abort(new Error('NoSqlConfigStore is closed.'));
+        }
+        return this.#closePromise;
+    }
+    /** Acknowledges settled provider cleanup failures without repeating callbacks or reopening the store. */
+    retryCleanup() {
+        if (!this.#closePromise)
+            return Promise.reject(new Error('NoSqlConfigStore cleanup requires terminal close.'));
+        this.#retryPromise ??= Promise.resolve().then(async () => {
+            await this.#closePromise.catch(() => undefined);
+            this.#keyProviderFailures.clear();
+            this.#retainedOperations.clear();
+        });
+        return this.#retryPromise;
+    }
+    get(keyArg, optionsArg = {}) {
+        const key = validateName(keyArg, 'config key', 1024);
+        const databaseOptions = this.#databaseOptions(optionsArg);
+        return this.#runOperation(async (operationArg) => {
+            const record = await this.#records.getInstance(this.#selector(key), databaseOptions);
+            return record ? this.#decrypt(key, record.encryptedValue, operationArg) : undefined;
+        });
+    }
+    set(keyArg, valueArg, optionsArg = {}) {
+        const key = validateName(keyArg, 'config key', 1024);
+        const serialized = this.#serialize(valueArg);
+        const databaseOptions = this.#databaseOptions(optionsArg);
+        return this.#runOperation(async (operationArg) => {
+            const encryptedValue = await this.#encrypt(key, serialized, operationArg);
+            this.#assertOpen();
+            await this.#records.atomicUpdate({ id: this.#selector(key).id }, {
+                $set: { homeId: this.#homeId, integrationDomain: this.#integrationDomain, key, encryptedValue },
+            }, { upsert: true, ...databaseOptions });
+        });
+    }
+    /** Insert-only persistence for callers that must never replace an existing key. */
+    create(keyArg, valueArg, optionsArg = {}) {
+        const key = validateName(keyArg, 'config key', 1024);
+        const serialized = this.#serialize(valueArg);
+        const databaseOptions = this.#databaseOptions(optionsArg);
+        return this.#runOperation(async (operationArg) => {
+            const record = Object.assign(new this.#records(), this.#selector(key), {
+                encryptedValue: await this.#encrypt(key, serialized, operationArg),
+            });
+            this.#assertOpen();
+            await this.#records.insert(record, databaseOptions);
+        });
+    }
+    delete(keyArg, optionsArg = {}) {
+        const key = validateName(keyArg, 'config key', 1024);
+        const databaseOptions = this.#databaseOptions(optionsArg);
+        return this.#runOperation(async () => {
+            await this.#records.atomicDelete(this.#selector(key), databaseOptions);
+        });
+    }
+    list(prefixArg = '', optionsArg = {}) {
+        if (prefixArg !== '')
+            validateName(prefixArg, 'config key prefix', 1024);
+        const databaseOptions = this.#databaseOptions(optionsArg);
+        return this.#runOperation(async () => {
+            const records = await this.#records.getInstances({
+                homeId: this.#homeId,
+                integrationDomain: this.#integrationDomain,
+            }, databaseOptions);
+            return records.map((recordArg) => recordArg.key).filter((keyArg) => keyArg.startsWith(prefixArg)).sort();
+        });
+    }
+    #databaseOptions(optionsArg) {
+        if (!optionsArg || Object.getPrototypeOf(optionsArg) !== Object.prototype ||
+            Reflect.ownKeys(optionsArg).some((keyArg) => keyArg !== 'session' ||
+                !('value' in Object.getOwnPropertyDescriptor(optionsArg, keyArg)))) {
+            throw new TypeError('Config operation options accept only a caller-owned SmartdataSession.');
+        }
+        const session = Object.getOwnPropertyDescriptor(optionsArg, 'session')?.value;
+        if (session === undefined)
+            return { timeoutMS: this.#timeoutMs };
+        if (!(session instanceof plugins.nosqldb.SmartdataSession)) {
+            throw new TypeError('Config operation session must be a caller-owned SmartdataSession.');
+        }
+        return { session };
+    }
+    #selector(keyArg) {
+        return {
+            id: JSON.stringify([this.#homeId, this.#integrationDomain, keyArg]),
+            homeId: this.#homeId,
+            integrationDomain: this.#integrationDomain,
+            key: keyArg,
+        };
+    }
+    #aad(keyArg, keyIdArg) {
+        return Buffer.from(JSON.stringify([1, this.#homeId, this.#integrationDomain, keyArg, keyIdArg]), 'utf8');
+    }
+    #serialize(valueArg) {
+        assertJsonValue(valueArg);
+        const serialized = JSON.stringify(valueArg);
+        if (Buffer.byteLength(serialized, 'utf8') > this.#maxValueBytes) {
+            throw new RangeError(`Config value exceeds the ${this.#maxValueBytes}-byte limit; large payloads require object storage.`);
+        }
+        return serialized;
+    }
+    async #encrypt(keyArg, serializedArg, operationArg) {
+        const encryptionKey = await this.#lookupKey((signalArg) => this.#keyProvider.currentKey(signalArg), operationArg);
+        this.#assertOpen();
+        const keyId = validateName(encryptionKey.id, 'encryption key ID', 128);
+        const key = copyKey(encryptionKey.key);
+        try {
+            const nonce = plugins.crypto.randomBytes(12);
+            const cipher = plugins.crypto.createCipheriv('aes-256-gcm', key, nonce);
+            cipher.setAAD(this.#aad(keyArg, keyId));
+            const ciphertext = Buffer.concat([cipher.update(serializedArg, 'utf8'), cipher.final()]);
+            return { version: 1, keyId, nonce: nonce.toString('base64'), ciphertext: ciphertext.toString('base64'), tag: cipher.getAuthTag().toString('base64') };
+        }
+        finally {
+            key.fill(0);
+        }
+    }
+    async #decrypt(keyArg, valueArg, operationArg) {
+        if (!valueArg || valueArg.version !== 1)
+            throw new Error('Stored config encryption envelope is invalid.');
+        const keyId = validateName(valueArg.keyId, 'stored encryption key ID', 128);
+        const nonce = decodeBase64(valueArg.nonce, 12, 12);
+        const tag = decodeBase64(valueArg.tag, 16, 16);
+        const ciphertext = decodeBase64(valueArg.ciphertext, this.#maxValueBytes);
+        const decryptionKey = await this.#lookupKey((signalArg) => this.#keyProvider.keyForId(keyId, signalArg), operationArg);
+        this.#assertOpen();
+        const key = copyKey(decryptionKey);
+        try {
+            const decipher = plugins.crypto.createDecipheriv('aes-256-gcm', key, nonce);
+            decipher.setAAD(this.#aad(keyArg, keyId));
+            decipher.setAuthTag(tag);
+            const plaintext = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+            try {
+                const value = JSON.parse(plaintext.toString('utf8'));
+                assertJsonValue(value);
+                return value;
+            }
+            finally {
+                plaintext.fill(0);
+            }
+        }
+        catch {
+            throw new Error('Stored config failed authentication or JSON validation.');
+        }
+        finally {
+            key.fill(0);
+        }
+    }
+    async #lookupKey(lookupArg, operationArg) {
+        this.#assertOpen();
+        const controller = new AbortController();
+        const signal = AbortSignal.any([controller.signal, this.#lifetime.signal]);
+        let resolveProvider;
+        let rejectProvider;
+        const provider = new Promise((resolveArg, rejectArg) => {
+            resolveProvider = resolveArg;
+            rejectProvider = rejectArg;
+        });
+        let abortLookup;
+        const settlement = provider.then(() => undefined, (errorArg) => {
+            if (signal.aborted && errorArg !== signal.reason) {
+                operationArg.providerFailed = true;
+                this.#keyProviderFailures.add(new Error('Config encryption key provider rejected after cancellation.'));
+            }
+        }).finally(() => {
+            this.#keyLookups.delete(settlement);
+            operationArg.keyLookups.delete(settlement);
+            if (operationArg.settled && !operationArg.keyLookups.size && !operationArg.providerFailed) {
+                this.#retainedOperations.delete(operationArg);
+            }
+            signal.removeEventListener('abort', abortLookup);
+        });
+        // Own the actual callback promise before invoking foreign code, including synchronous close reentry.
+        this.#keyLookups.add(settlement);
+        operationArg.keyLookups.add(settlement);
+        const cancellation = new Promise((resolveArg, rejectArg) => {
+            void resolveArg;
+            abortLookup = () => {
+                rejectArg(signal.reason);
+            };
+            signal.addEventListener('abort', abortLookup, { once: true });
+        });
+        const timer = setTimeout(() => controller.abort(new Error('Config encryption key lookup timed out.')), this.#timeoutMs);
+        timer.unref();
+        try {
+            try {
+                resolveProvider(lookupArg(signal));
+            }
+            catch (errorArg) {
+                rejectProvider(errorArg);
+            }
+            const result = await Promise.race([provider, cancellation]);
+            signal.throwIfAborted();
+            this.#assertOpen();
+            return result;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    #runOperation(operationArg) {
+        if (this.#lifetime.signal.aborted) {
+            return Promise.reject(this.#lifetime.signal.reason);
         }
-        catch (error) {
-            return {};
+        if (this.#pendingOperations + this.#retainedOperations.size >= this.#maxPendingOperations) {
+            return Promise.reject(new Error(`NoSqlConfigStore operation capacity reached: ${this.#maxPendingOperations}.`));
         }
+        this.#pendingOperations += 1;
+        const state = { keyLookups: new Set(), settled: false, providerFailed: false };
+        const operation = this.#operationTail.then(() => {
+            this.#assertOpen();
+            return operationArg(state);
+        }).finally(() => {
+            state.settled = true;
+            this.#pendingOperations -= 1;
+            if (state.keyLookups.size || state.providerFailed)
+                this.#retainedOperations.add(state);
+        });
+        this.#operationTail = operation.then(() => undefined, () => undefined);
+        return operation;
     }
-    async writeFile(dataArg) {
-        await plugins.fs.mkdir(plugins.path.dirname(this.filePath), { recursive: true });
-        await plugins.fs.writeFile(this.filePath, `${JSON.stringify(dataArg, null, 2)}\n`);
+    #assertOpen() {
+        this.#lifetime.signal.throwIfAborted();
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.configstore.js","sourceRoot":"","sources":["../../ts/core/classes.configstore.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,uBAAuB,EAA8B,MAAM,2BAA2B,CAAC;AAmChG,MAAM,YAAY,GAAG,CAAC,QAAgB,EAAE,OAAe,EAAE,YAAoB,EAAU,EAAE;IACvF,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,IAAI,QAAQ,CAAC,MAAM,GAAG,YAAY,IAAI,iBAAiB,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC;QAChI,MAAM,IAAI,SAAS,CAAC,GAAG,OAAO,mEAAmE,YAAY,cAAc,CAAC,CAAC;IAC/H,CAAC;IACD,OAAO,QAAQ,CAAC;AAClB,CAAC,CAAC;AAEF,MAAM,cAAc,GAAG,CAAC,QAAgB,EAAE,OAAe,EAAE,UAAkB,EAAU,EAAE;IACvF,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,QAAQ,CAAC,IAAI,QAAQ,GAAG,CAAC,IAAI,QAAQ,GAAG,UAAU,EAAE,CAAC;QAC7E,MAAM,IAAI,UAAU,CAAC,GAAG,OAAO,sCAAsC,UAAU,GAAG,CAAC,CAAC;IACtF,CAAC;IACD,OAAO,QAAQ,CAAC;AAClB,CAAC,CAAC;AAEF,MAAM,eAAe,GAAG,CAAC,QAAiB,EAAE,YAAY,GAAG,IAAI,GAAG,EAAU,EAAE,QAAQ,GAAG,CAAC,EAAQ,EAAE;IAClG,IAAI,QAAQ,KAAK,IAAI,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,OAAO,QAAQ,KAAK,SAAS;QAAE,OAAO;IAC/F,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAC;QAAE,OAAO;IACtE,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,QAAQ,IAAI,EAAE,IAAI,YAAY,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC;QACjF,MAAM,IAAI,SAAS,CAAC,mFAAmF,CAAC,CAAC;IAC3G,CAAC;IACD,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,MAAM,CAAC,cAAc,CAAC,QAAQ,CAAC,KAAK,MAAM,CAAC,SAAS,IAAI,MAAM,CAAC,cAAc,CAAC,QAAQ,CAAC,KAAK,IAAI,EAAE,CAAC;QACjI,MAAM,IAAI,SAAS,CAAC,2DAA2D,CAAC,CAAC;IACnF,CAAC;IACD,YAAY,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IAC3B,IAAI,CAAC;QACH,KAAK,MAAM,GAAG,IAAI,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;YAC5C,IAAI,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,GAAG,KAAK,QAAQ;gBAAE,SAAS;YAC1D,MAAM,UAAU,GAAG,MAAM,CAAC,wBAAwB,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC;YAClE,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,CAAC,UAAU,IAAI,CAAC,CAAC,OAAO,IAAI,UAAU,CAAC,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,CAAC;gBACjG,MAAM,IAAI,SAAS,CAAC,oEAAoE,CAAC,CAAC;YAC5F,CAAC;YACD,IAAI,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,gBAAgB,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,IAAI,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;gBAC/F,MAAM,IAAI,SAAS,CAAC,mDAAmD,CAAC,CAAC;YAC3E,CAAC;YACD,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,UAAU,CAAC,KAAK,KAAK,SAAS;gBAAE,SAAS;YACzE,eAAe,CAAC,UAAU,CAAC,KAAK,EAAE,YAAY,EAAE,QAAQ,GAAG,CAAC,CAAC,CAAC;QAChE,CAAC;QACD,IAAI,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,MAAM,KAAK,QAAQ,CAAC,MAAM,EAAE,CAAC;YAChF,MAAM,IAAI,SAAS,CAAC,qEAAqE,CAAC,CAAC;QAC7F,CAAC;IACH,CAAC;YAAS,CAAC;QACT,YAAY,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IAChC,CAAC;AACH,CAAC,CAAC;AAEF,MAAM,OAAO,GAAG,CAAC,QAAgC,EAAU,EAAE;IAC3D,IAAI,CAAC,CAAC,QAAQ,YAAY,UAAU,CAAC,IAAI,QAAQ,CAAC,UAAU,KAAK,EAAE,EAAE,CAAC;QACpE,MAAM,IAAI,SAAS,CAAC,qDAAqD,CAAC,CAAC;IAC7E,CAAC;IACD,OAAO,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;AAC/B,CAAC,CAAC;AAEF,MAAM,YAAY,GAAG,CAAC,QAAgB,EAAE,eAAuB,EAAE,aAAsB,EAAU,EAAE;IACjG,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,QAAQ,CAAC,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,eAAe,GAAG,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC;QACzF,MAAM,IAAI,KAAK,CAAC,+CAA+C,CAAC,CAAC;IACnE,CAAC;IACD,MAAM,OAAO,GAAG,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;IAChD,IAAI,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC,KAAK,QAAQ,IAAI,OAAO,CAAC,UAAU,GAAG,eAAe,IAAI,CAAC,aAAa,KAAK,SAAS,IAAI,OAAO,CAAC,UAAU,KAAK,aAAa,CAAC,EAAE,CAAC;QAC7J,MAAM,IAAI,KAAK,CAAC,+CAA+C,CAAC,CAAC;IACnE,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC,CAAC;AAEF,uFAAuF;AACvF,MAAM,OAAO,gBAAgB;IAClB,QAAQ,CAAiC;IACzC,OAAO,CAAS;IAChB,kBAAkB,CAAS;IAC3B,YAAY,CAA+B;IAC3C,UAAU,CAAS;IACnB,qBAAqB,CAAS;IAC9B,cAAc,CAAS;IACvB,SAAS,GAAG,IAAI,eAAe,EAAE,CAAC;IAClC,aAAa,GAAG,IAAI,GAAG,EAAiB,CAAC;IACzC,WAAW,GAAG,IAAI,GAAG,EAAiB,CAAC;IACvC,mBAAmB,GAAG,IAAI,GAAG,EAA8B,CAAC;IAC5D,oBAAoB,GAAG,IAAI,GAAG,EAAS,CAAC;IACjD,cAAc,GAAkB,OAAO,CAAC,OAAO,EAAE,CAAC;IAClD,kBAAkB,GAAG,CAAC,CAAC;IACvB,aAAa,CAAiB;IAC9B,aAAa,CAAiB;IAE9B,YAAY,UAAoC;QAC9C,IAAI,CAAC,OAAO,GAAG,YAAY,CAAC,UAAU,CAAC,MAAM,EAAE,QAAQ,EAAE,GAAG,CAAC,CAAC;QAC9D,IAAI,CAAC,kBAAkB,GAAG,YAAY,CAAC,UAAU,CAAC,iBAAiB,EAAE,mBAAmB,EAAE,GAAG,CAAC,CAAC;QAC/F,IAAI,CAAC,YAAY,GAAG,UAAU,CAAC,WAAW,CAAC;QAC3C,IAAI,CAAC,UAAU,GAAG,cAAc,CAAC,UAAU,CAAC,SAAS,IAAI,IAAI,EAAE,WAAW,EAAE,MAAM,CAAC,CAAC;QACpF,IAAI,CAAC,qBAAqB,GAAG,cAAc,CAAC,UAAU,CAAC,oBAAoB,IAAI,IAAI,EAAE,sBAAsB,EAAE,KAAK,CAAC,CAAC;QACpH,IAAI,CAAC,cAAc,GAAG,cAAc,CAAC,UAAU,CAAC,aAAa,IAAI,KAAK,EAAE,eAAe,EAAE,OAAO,CAAC,CAAC;QAClG,IAAI,CAAC,IAAI,CAAC,YAAY,IAAI,OAAO,IAAI,CAAC,YAAY,CAAC,UAAU,KAAK,UAAU,IAAI,OAAO,IAAI,CAAC,YAAY,CAAC,QAAQ,KAAK,UAAU,EAAE,CAAC;YACjI,MAAM,IAAI,SAAS,CAAC,4DAA4D,CAAC,CAAC;QACpF,CAAC;QACD,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,gBAAgB,CAAC,EAAE,EAAE,EAAE,UAAU,CAAC,EAAE,EAAE,EAAE,uBAAuB,CAAC,CAAC;IACnG,CAAC;IAEM,QAAQ;QACb,OAAO,MAAM,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,OAAO,EAAE,iBAAiB,EAAE,IAAI,CAAC,kBAAkB,EAAE,CAAC,CAAC;IAC7F,CAAC;IAEM,KAAK,CAAC,UAAU,CAAC,UAAU,GAAsC,EAAE;QACxE,IAAI,CAAC,WAAW,EAAE,CAAC;QACnB,IAAI,CAAC,UAAU,IAAI,MAAM,CAAC,cAAc,CAAC,UAAU,CAAC,KAAK,MAAM,CAAC,SAAS;YACvE,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,KAAK,QAAQ;gBAC9D,CAAC,CAAC,OAAO,IAAI,MAAM,CAAC,wBAAwB,CAAC,UAAU,EAAE,MAAM,CAAE,CAAC,CAAC,EAAE,CAAC;YACxE,MAAM,IAAI,SAAS,CAAC,2DAA2D,CAAC,CAAC;QACnF,CAAC;QACD,MAAM,MAAM,GAAG,MAAM,CAAC,wBAAwB,CAAC,UAAU,EAAE,QAAQ,CAAC,EAAE,KAAgC,CAAC;QACvG,IAAI,MAAM,KAAK,SAAS,IAAI,CAAC,CAAC,MAAM,YAAY,WAAW,CAAC,EAAE,CAAC;YAC7D,MAAM,IAAI,SAAS,CAAC,sDAAsD,CAAC,CAAC;QAC9E,CAAC;QACD,MAAM,EAAE,cAAc,EAAE,CAAC;QACzB,MAAM,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,iBAAiB,CAAC;YAClD,IAAI,EAAE,kBAAkB;YACxB,SAAS,EAAE,IAAI,CAAC,UAAU;YAC1B,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM;SAC1F,CAAC,CAAC;QACH,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;QACpC,IAAI,CAAC;YACH,MAAM,WAAW,CAAC;YAClB,IAAI,CAAC,WAAW,EAAE,CAAC;QACrB,CAAC;gBAAS,CAAC;YACT,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;QACzC,CAAC;IACH,CAAC;IAED,8EAA8E;IACvE,KAAK;QACV,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC;YACxB,IAAI,CAAC,aAAa,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,IAAI,CAAC,KAAK,IAAI,EAAE;gBACrD,MAAM,OAAO,CAAC,UAAU,CAAC;oBACvB,GAAG,IAAI,CAAC,aAAa;oBACrB,IAAI,CAAC,cAAc;oBACnB,GAAG,IAAI,CAAC,WAAW;iBACpB,CAAC,CAAC;gBACH,IAAI,IAAI,CAAC,oBAAoB,CAAC,IAAI,EAAE,CAAC;oBACnC,MAAM,IAAI,cAAc,CAAC,CAAC,GAAG,IAAI,CAAC,oBAAoB,CAAC,EAAE,+CAA+C,CAAC,CAAC;gBAC5G,CAAC;YACH,CAAC,CAAC,CAAC;YACH,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,6BAA6B,CAAC,CAAC,CAAC;QACjE,CAAC;QACD,OAAO,IAAI,CAAC,aAAa,CAAC;IAC5B,CAAC;IAED,yGAAyG;IAClG,YAAY;QACjB,IAAI,CAAC,IAAI,CAAC,aAAa;YAAE,OAAO,OAAO,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,mDAAmD,CAAC,CAAC,CAAC;QAC/G,IAAI,CAAC,aAAa,KAAK,OAAO,CAAC,OAAO,EAAE,CAAC,IAAI,CAAC,KAAK,IAAI,EAAE;YACvD,MAAM,IAAI,CAAC,aAAc,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;YACjD,IAAI,CAAC,oBAAoB,CAAC,KAAK,EAAE,CAAC;YAClC,IAAI,CAAC,mBAAmB,CAAC,KAAK,EAAE,CAAC;QACnC,CAAC,CAAC,CAAC;QACH,OAAO,IAAI,CAAC,aAAa,CAAC;IAC5B,CAAC;IAEM,GAAG,CAAS,MAAc,EAAE,UAAU,GAAiC,EAAE;QAC9E,MAAM,GAAG,GAAG,YAAY,CAAC,MAAM,EAAE,YAAY,EAAE,IAAI,CAAC,CAAC;QACrD,MAAM,eAAe,GAAG,IAAI,CAAC,gBAAgB,CAAC,UAAU,CAAC,CAAC;QAC1D,OAAO,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,YAAY,EAAE,EAAE;YAC/C,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE,eAAe,CAAC,CAAC;YACrF,OAAO,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAS,GAAG,EAAE,MAAM,CAAC,cAAc,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QAC9F,CAAC,CAAC,CAAC;IACL,CAAC;IAEM,GAAG,CAAS,MAAc,EAAE,QAAgB,EAAE,UAAU,GAAiC,EAAE;QAChG,MAAM,GAAG,GAAG,YAAY,CAAC,MAAM,EAAE,YAAY,EAAE,IAAI,CAAC,CAAC;QACrD,MAAM,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;QAC7C,MAAM,eAAe,GAAG,IAAI,CAAC,gBAAgB,CAAC,UAAU,CAAC,CAAC;QAC1D,OAAO,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,YAAY,EAAE,EAAE;YAC/C,MAAM,cAAc,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,GAAG,EAAE,UAAU,EAAE,YAAY,CAAC,CAAC;YAC1E,IAAI,CAAC,WAAW,EAAE,CAAC;YACnB,MAAM,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,EAAE,EAAE,EAAE,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE;gBAC/D,IAAI,EAAE,EAAE,MAAM,EAAE,IAAI,CAAC,OAAO,EAAE,iBAAiB,EAAE,IAAI,CAAC,kBAAkB,EAAE,GAAG,EAAE,cAAc,EAAE;aAChG,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,eAAe,EAAE,CAAC,CAAC;QAC3C,CAAC,CAAC,CAAC;IACL,CAAC;IAED,mFAAmF;IAC5E,MAAM,CAAS,MAAc,EAAE,QAAgB,EAAE,UAAU,GAAyB,EAAE;QAC3F,MAAM,GAAG,GAAG,YAAY,CAAC,MAAM,EAAE,YAAY,EAAE,IAAI,CAAC,CAAC;QACrD,MAAM,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;QAC7C,MAAM,eAAe,GAAG,IAAI,CAAC,gBAAgB,CAAC,UAAU,CAAC,CAAC;QAC1D,OAAO,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,YAAY,EAAE,EAAE;YAC/C,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,IAAI,CAAC,QAAQ,EAAE,EAAE,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE;gBACrE,cAAc,EAAE,MAAM,IAAI,CAAC,QAAQ,CAAC,GAAG,EAAE,UAAU,EAAE,YAAY,CAAC;aACnE,CAAC,CAAC;YACH,IAAI,CAAC,WAAW,EAAE,CAAC;YACnB,MAAM,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;QACtD,CAAC,CAAC,CAAC;IACL,CAAC;IAEM,MAAM,CAAC,MAAc,EAAE,UAAU,GAAiC,EAAE;QACzE,MAAM,GAAG,GAAG,YAAY,CAAC,MAAM,EAAE,YAAY,EAAE,IAAI,CAAC,CAAC;QACrD,MAAM,eAAe,GAAG,IAAI,CAAC,gBAAgB,CAAC,UAAU,CAAC,CAAC;QAC1D,OAAO,IAAI,CAAC,aAAa,CAAC,KAAK,IAAI,EAAE;YACnC,MAAM,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE,eAAe,CAAC,CAAC;QACzE,CAAC,CAAC,CAAC;IACL,CAAC;IAEM,IAAI,CAAC,SAAS,GAAG,EAAE,EAAE,UAAU,GAAiC,EAAE;QACvE,IAAI,SAAS,KAAK,EAAE;YAAE,YAAY,CAAC,SAAS,EAAE,mBAAmB,EAAE,IAAI,CAAC,CAAC;QACzE,MAAM,eAAe,GAAG,IAAI,CAAC,gBAAgB,CAAC,UAAU,CAAC,CAAC;QAC1D,OAAO,IAAI,CAAC,aAAa,CAAC,KAAK,IAAI,EAAE;YACnC,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC;gBAC/C,MAAM,EAAE,IAAI,CAAC,OAAO;gBACpB,iBAAiB,EAAE,IAAI,CAAC,kBAAkB;aAC3C,EAAE,eAAe,CAAC,CAAC;YACpB,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;QAC3G,CAAC,CAAC,CAAC;IACL,CAAC;IAED,gBAAgB,CAAC,UAAwC;QACvD,IAAI,CAAC,UAAU,IAAI,MAAM,CAAC,cAAc,CAAC,UAAU,CAAC,KAAK,MAAM,CAAC,SAAS;YACvE,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,KAAK,SAAS;gBAC/D,CAAC,CAAC,OAAO,IAAI,MAAM,CAAC,wBAAwB,CAAC,UAAU,EAAE,MAAM,CAAE,CAAC,CAAC,EAAE,CAAC;YACxE,MAAM,IAAI,SAAS,CAAC,uEAAuE,CAAC,CAAC;QAC/F,CAAC;QACD,MAAM,OAAO,GAAG,MAAM,CAAC,wBAAwB,CAAC,UAAU,EAAE,SAAS,CAAC,EAAE,KAAqD,CAAC;QAC9H,IAAI,OAAO,KAAK,SAAS;YAAE,OAAO,EAAE,SAAS,EAAE,IAAI,CAAC,UAAU,EAAE,CAAC;QACjE,IAAI,CAAC,CAAC,OAAO,YAAY,OAAO,CAAC,OAAO,CAAC,gBAAgB,CAAC,EAAE,CAAC;YAC3D,MAAM,IAAI,SAAS,CAAC,mEAAmE,CAAC,CAAC;QAC3F,CAAC;QACD,OAAO,EAAE,OAAO,EAAE,CAAC;IACrB,CAAC;IAED,SAAS,CAAC,MAAc;QACtB,OAAO;YACL,EAAE,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,kBAAkB,EAAE,MAAM,CAAC,CAAC;YACnE,MAAM,EAAE,IAAI,CAAC,OAAO;YACpB,iBAAiB,EAAE,IAAI,CAAC,kBAAkB;YAC1C,GAAG,EAAE,MAAM;SACZ,CAAC;IACJ,CAAC;IAED,IAAI,CAAC,MAAc,EAAE,QAAgB;QACnC,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,kBAAkB,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;IAC3G,CAAC;IAED,UAAU,CAAC,QAAiB;QAC1B,eAAe,CAAC,QAAQ,CAAC,CAAC;QAC1B,MAAM,UAAU,GAAG,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;QAC5C,IAAI,MAAM,CAAC,UAAU,CAAC,UAAU,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC,cAAc,EAAE,CAAC;YAChE,MAAM,IAAI,UAAU,CAAC,4BAA4B,IAAI,CAAC,cAAc,qDAAqD,CAAC,CAAC;QAC7H,CAAC;QACD,OAAO,UAAU,CAAC;IACpB,CAAC;IAED,KAAK,CAAC,QAAQ,CAAC,MAAc,EAAE,aAAqB,EAAE,YAAwC;QAC5F,MAAM,aAAa,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,SAAS,CAAC,EAAE,YAAY,CAAC,CAAC;QAClH,IAAI,CAAC,WAAW,EAAE,CAAC;QACnB,MAAM,KAAK,GAAG,YAAY,CAAC,aAAa,CAAC,EAAE,EAAE,mBAAmB,EAAE,GAAG,CAAC,CAAC;QACvE,MAAM,GAAG,GAAG,OAAO,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC;QACvC,IAAI,CAAC;YACH,MAAM,KAAK,GAAG,OAAO,CAAC,MAAM,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC;YAC7C,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,cAAc,CAAC,aAAa,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;YACxE,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC;YACxC,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,aAAa,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;YACzF,OAAO,EAAE,OAAO,EAAE,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,UAAU,EAAE,UAAU,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,UAAU,EAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC;QACxJ,CAAC;gBAAS,CAAC;YACT,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACd,CAAC;IACH,CAAC;IAED,KAAK,CAAC,QAAQ,CAAS,MAAc,EAAE,QAA+B,EAAE,YAAwC;QAC9G,IAAI,CAAC,QAAQ,IAAI,QAAQ,CAAC,OAAO,KAAK,CAAC;YAAE,MAAM,IAAI,KAAK,CAAC,+CAA+C,CAAC,CAAC;QAC1G,MAAM,KAAK,GAAG,YAAY,CAAC,QAAQ,CAAC,KAAK,EAAE,0BAA0B,EAAE,GAAG,CAAC,CAAC;QAC5E,MAAM,KAAK,GAAG,YAAY,CAAC,QAAQ,CAAC,KAAK,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;QACnD,MAAM,GAAG,GAAG,YAAY,CAAC,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;QAC/C,MAAM,UAAU,GAAG,YAAY,CAAC,QAAQ,CAAC,UAAU,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC;QAC1E,MAAM,aAAa,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC,EAAE,YAAY,CAAC,CAAC;QACvH,IAAI,CAAC,WAAW,EAAE,CAAC;QACnB,MAAM,GAAG,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;QACnC,IAAI,CAAC;YACH,MAAM,QAAQ,GAAG,OAAO,CAAC,MAAM,CAAC,gBAAgB,CAAC,aAAa,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;YAC5E,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC;YAC1C,QAAQ,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;YACzB,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,UAAU,CAAC,EAAE,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;YACjF,IAAI,CAAC;gBACH,MAAM,KAAK,GAAY,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC;gBAC9D,eAAe,CAAC,KAAK,CAAC,CAAC;gBACvB,OAAO,KAAe,CAAC;YACzB,CAAC;oBAAS,CAAC;gBACT,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YACpB,CAAC;QACH,CAAC;QAAC,MAAM,CAAC;YACP,MAAM,IAAI,KAAK,CAAC,yDAAyD,CAAC,CAAC;QAC7E,CAAC;gBAAS,CAAC;YACT,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACd,CAAC;IACH,CAAC;IAED,KAAK,CAAC,UAAU,CAAU,SAAuD,EAAE,YAAwC;QACzH,IAAI,CAAC,WAAW,EAAE,CAAC;QACnB,MAAM,UAAU,GAAG,IAAI,eAAe,EAAE,CAAC;QACzC,MAAM,MAAM,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC,UAAU,CAAC,MAAM,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC;QAC3E,IAAI,eAAoE,CAAC;QACzE,IAAI,cAA4C,CAAC;QACjD,MAAM,QAAQ,GAAG,IAAI,OAAO,CAAU,CAAC,UAAU,EAAE,SAAS,EAAE,EAAE;YAC9D,eAAe,GAAG,UAAU,CAAC;YAC7B,cAAc,GAAG,SAAS,CAAC;QAC7B,CAAC,CAAC,CAAC;QACH,IAAI,WAAwB,CAAC;QAC7B,MAAM,UAAU,GAAG,QAAQ,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,SAAS,EAAE,CAAC,QAAiB,EAAE,EAAE;YACtE,IAAI,MAAM,CAAC,OAAO,IAAI,QAAQ,KAAK,MAAM,CAAC,MAAM,EAAE,CAAC;gBACjD,YAAY,CAAC,cAAc,GAAG,IAAI,CAAC;gBACnC,IAAI,CAAC,oBAAoB,CAAC,GAAG,CAAC,IAAI,KAAK,CAAC,6DAA6D,CAAC,CAAC,CAAC;YAC1G,CAAC;QACH,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,EAAE;YACd,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;YACpC,YAAY,CAAC,UAAU,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;YAC3C,IAAI,YAAY,CAAC,OAAO,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,IAAI,IAAI,CAAC,YAAY,CAAC,cAAc,EAAE,CAAC;gBAC1F,IAAI,CAAC,mBAAmB,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;YAChD,CAAC;YACD,MAAM,CAAC,mBAAmB,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;QACnD,CAAC,CAAC,CAAC;QACH,qGAAqG;QACrG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;QACjC,YAAY,CAAC,UAAU,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;QACxC,MAAM,YAAY,GAAG,IAAI,OAAO,CAAQ,CAAC,UAAU,EAAE,SAAS,EAAE,EAAE;YAChE,KAAK,UAAU,CAAC;YAChB,WAAW,GAAG,GAAG,EAAE;gBACjB,SAAS,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;YAC3B,CAAC,CAAC;YACF,MAAM,CAAC,gBAAgB,CAAC,OAAO,EAAE,WAAW,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;QAChE,CAAC,CAAC,CAAC;QACH,MAAM,KAAK,GAAG,UAAU,CAAC,GAAG,EAAE,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAC,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;QACxH,KAAK,CAAC,KAAK,EAAE,CAAC;QACd,IAAI,CAAC;YACH,IAAI,CAAC;gBAAC,eAAe,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC;YAAC,CAAC;YAAC,OAAO,QAAQ,EAAE,CAAC;gBAAC,cAAc,CAAC,QAAQ,CAAC,CAAC;YAAC,CAAC;YAC1F,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,YAAY,CAAC,CAAC,CAAC;YAC5D,MAAM,CAAC,cAAc,EAAE,CAAC;YACxB,IAAI,CAAC,WAAW,EAAE,CAAC;YACnB,OAAO,MAAM,CAAC;QAChB,CAAC;gBAAS,CAAC;YACT,YAAY,CAAC,KAAK,CAAC,CAAC;QACtB,CAAC;IACH,CAAC;IAED,aAAa,CAAU,YAAwE;QAC7F,IAAI,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;YAClC,OAAO,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QACtD,CAAC;QACD,IAAI,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC,mBAAmB,CAAC,IAAI,IAAI,IAAI,CAAC,qBAAqB,EAAE,CAAC;YAC1F,OAAO,OAAO,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,gDAAgD,IAAI,CAAC,qBAAqB,GAAG,CAAC,CAAC,CAAC;QAClH,CAAC;QACD,IAAI,CAAC,kBAAkB,IAAI,CAAC,CAAC;QAC7B,MAAM,KAAK,GAA+B,EAAE,UAAU,EAAE,IAAI,GAAG,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE,cAAc,EAAE,KAAK,EAAE,CAAC;QAC3G,MAAM,SAAS,GAAG,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,GAAG,EAAE;YAC9C,IAAI,CAAC,WAAW,EAAE,CAAC;YACnB,OAAO,YAAY,CAAC,KAAK,CAAC,CAAC;QAC7B,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,EAAE;YACd,KAAK,CAAC,OAAO,GAAG,IAAI,CAAC;YACrB,IAAI,CAAC,kBAAkB,IAAI,CAAC,CAAC;YAC7B,IAAI,KAAK,CAAC,UAAU,CAAC,IAAI,IAAI,KAAK,CAAC,cAAc;gBAAE,IAAI,CAAC,mBAAmB,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QACzF,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,cAAc,GAAG,SAAS,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,SAAS,EAAE,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;QACvE,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,WAAW;QACT,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,cAAc,EAAE,CAAC;IACzC,CAAC;CACF"}

package/dist_ts/core/classes.discoveryengine.js

@@ -4,11 +4,21 @@ export class DiscoveryEngine {
         this.integrationRegistry = integrationRegistry;
     }
     async runActiveDiscovery(contextArg = {}) {
+        contextArg.abortSignal?.throwIfAborted();
         const candidates = [];
         for (const integration of this.integrationRegistry.list()) {
             const descriptor = integration.discoveryDescriptor;
             for (const probe of descriptor.getProbes()) {
-                const result = await probe.probe(contextArg);
+                contextArg.abortSignal?.throwIfAborted();
+                let result;
+                try {
+                    result = await probe.probe(contextArg);
+                }
+                catch (error) {
+                    contextArg.abortSignal?.throwIfAborted();
+                    throw error;
+                }
+                contextArg.abortSignal?.throwIfAborted();
                 for (const candidate of result.candidates) {
                     candidates.push({
                         ...candidate,
@@ -51,4 +61,4 @@ export class DiscoveryEngine {
         return matches;
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/core/classes.nativehomeadmission.d.ts

@@ -0,0 +1,19 @@
+import { NoSqlConfigStore } from './classes.configstore.js';
+import type { IConfigFlowContext, IIntegrationSetupContext, ILogger } from './types.js';
+export interface INativeHomeAdmissionOptions {
+    readonly homeId?: string;
+}
+/** A captured host selection, not an authentication credential. Persistence resources are borrowed. */
+export interface INativeAdmissionContext {
+    readonly homeId: string;
+    readonly configStore?: NoSqlConfigStore;
+    readonly logger?: ILogger;
+    readonly abortSignal?: AbortSignal;
+}
+/** Binds to independently selected host context only after all synchronous checks pass. */
+export declare class NativeHomeAdmission {
+    #private;
+    constructor(domainArg: string, optionsArg?: INativeHomeAdmissionOptions);
+    get homeId(): string | undefined;
+    admit(contextArg: IIntegrationSetupContext | IConfigFlowContext, configHomeIdArg?: string): INativeAdmissionContext;
+}

package/dist_ts/core/classes.nativehomeadmission.js

@@ -0,0 +1,84 @@
+import { NoSqlConfigStore } from './classes.configstore.js';
+const identifier = (valueArg, nameArg, maximumArg) => {
+    if (typeof valueArg !== 'string' || !valueArg || valueArg.length > maximumArg
+        || valueArg.trim() !== valueArg || /[\p{Cc}\p{Cs}]/u.test(valueArg)) {
+        throw new TypeError(`${nameArg} must be a non-empty identifier without surrounding whitespace or control characters, at most ${maximumArg} characters.`);
+    }
+    return valueArg;
+};
+const dataFields = (valueArg, allowedArg, nameArg) => {
+    if (!valueArg || typeof valueArg !== 'object'
+        || (Object.getPrototypeOf(valueArg) !== Object.prototype && Object.getPrototypeOf(valueArg) !== null)) {
+        throw new TypeError(`${nameArg} must be a plain data object.`);
+    }
+    const captured = Object.create(null);
+    for (const key of Reflect.ownKeys(valueArg)) {
+        const descriptor = Object.getOwnPropertyDescriptor(valueArg, key);
+        if (typeof key !== 'string' || !allowedArg.includes(key) || !descriptor
+            || !descriptor.enumerable || !('value' in descriptor)) {
+            throw new TypeError(`${nameArg} contains an unsupported field or accessor.`);
+        }
+        captured[key] = descriptor.value;
+    }
+    return captured;
+};
+const logger = (valueArg) => {
+    if (valueArg === undefined)
+        return undefined;
+    if (!valueArg || typeof valueArg !== 'object')
+        throw new TypeError('Native logger must expose a log method.');
+    let target = valueArg;
+    for (let depth = 0; target && depth < 16; depth += 1) {
+        const descriptor = Object.getOwnPropertyDescriptor(target, 'log');
+        if (descriptor) {
+            if ('value' in descriptor && typeof descriptor.value === 'function')
+                return valueArg;
+            break;
+        }
+        target = Object.getPrototypeOf(target);
+    }
+    throw new TypeError('Native logger must expose a data-method log function.');
+};
+/** Binds to independently selected host context only after all synchronous checks pass. */
+export class NativeHomeAdmission {
+    #domain;
+    #homeId;
+    constructor(domainArg, optionsArg = {}) {
+        this.#domain = identifier(domainArg, 'integrationDomain', 128);
+        const options = dataFields(optionsArg, ['homeId'], 'Native home options');
+        if (options.homeId !== undefined)
+            this.#homeId = identifier(options.homeId, 'homeId', 256);
+    }
+    get homeId() { return this.#homeId; }
+    admit(contextArg, configHomeIdArg) {
+        const context = dataFields(contextArg, ['homeId', 'configStore', 'logger', 'abortSignal'], 'Native context');
+        const homeId = identifier(context.homeId, 'Host-selected homeId', 256);
+        if (this.#homeId !== undefined && this.#homeId !== homeId)
+            throw new Error('Native owning home does not match the selected host home.');
+        if (configHomeIdArg !== undefined && identifier(configHomeIdArg, 'Configuration homeId', 256) !== homeId) {
+            throw new Error('Native configuration home does not match the selected host home.');
+        }
+        const configStore = context.configStore;
+        if (configStore !== undefined) {
+            if (!(configStore instanceof NoSqlConfigStore))
+                throw new TypeError('Native configStore must be an actual NoSqlConfigStore.');
+            // Call the owning implementation: a structural or overridden getScope cannot grant admission.
+            const scope = NoSqlConfigStore.prototype.getScope.call(configStore);
+            if (scope.homeId !== homeId || scope.integrationDomain !== this.#domain) {
+                throw new Error('Native configStore home/domain does not match the admitted owner.');
+            }
+        }
+        const capturedLogger = logger(context.logger);
+        const abortSignal = context.abortSignal;
+        if (abortSignal !== undefined) {
+            if (!(abortSignal instanceof AbortSignal))
+                throw new TypeError('Native abortSignal must be an AbortSignal.');
+            AbortSignal.prototype.throwIfAborted.call(abortSignal);
+        }
+        const captured = Object.freeze({ homeId, configStore: configStore,
+            logger: capturedLogger, abortSignal: abortSignal });
+        this.#homeId = homeId;
+        return captured;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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