@smarthome.exchange/integrations 0.2.0 → 2.0.0

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

@@ -0,0 +1,79 @@
+import { NativeHomeAdmission, type INativeAdmissionContext, type INativeHomeAdmissionOptions } from './classes.nativehomeadmission.js';
+import type { IConfigFlowContext, IIntegrationSetupContext } from './types.js';
+export interface INativeIntegrationOwnerOptions extends INativeHomeAdmissionOptions {
+    /** Shared limit for pending operations, runtimes, and retained cleanup resources. Defaults to 16. */
+    readonly capacity?: number;
+}
+export interface INativeOperationLease {
+    readonly context: INativeAdmissionContext;
+    readonly signal: AbortSignal;
+    assertOpen(): void;
+    /** Register immediately after allocation, before invoking initialization or other foreign callbacks. */
+    own(cleanupArg: () => Promise<void>): void;
+    close(): Promise<void>;
+}
+export interface INativeSetupLease extends INativeOperationLease {
+    /** Transfers this operation's cleanup ownership to the returned runtime. */
+    promoteToRuntime(): void;
+}
+interface INativeScopeState {
+    readonly lifetime: AbortController;
+    readonly leases: Set<NativeIntegrationLease>;
+    readonly operations: Set<Promise<unknown>>;
+    closed: boolean;
+    closePromise?: Promise<void>;
+    retryPromise?: Promise<void>;
+}
+declare class NativeIntegrationLease implements INativeSetupLease {
+    #private;
+    readonly context: INativeAdmissionContext;
+    readonly signal: AbortSignal;
+    constructor(stateArg: NativeOwnerState, scopeArg: INativeScopeState, contextArg: INativeAdmissionContext, runtimeAllowedArg: boolean);
+    get promoted(): boolean;
+    get weight(): number;
+    get failed(): boolean;
+    assertOpen(): void;
+    own(cleanupArg: () => Promise<void>): void;
+    promoteToRuntime(): void;
+    finish(): void;
+    close(): Promise<void>;
+    retryCleanup(): Promise<void>;
+}
+declare class NativeOwnerState {
+    #private;
+    readonly admission: NativeHomeAdmission;
+    readonly lifetime: AbortController;
+    readonly root: INativeScopeState;
+    closed: boolean;
+    constructor(domainArg: string, optionsArg: INativeIntegrationOwnerOptions);
+    assertOpen(scopeArg: INativeScopeState): void;
+    assertCapacity(): void;
+    createScope(): INativeScopeState;
+    admit(scopeArg: INativeScopeState, contextArg: IIntegrationSetupContext | IConfigFlowContext, configHomeIdArg?: string): INativeAdmissionContext;
+    run<TResult>(scopeArg: INativeScopeState, contextArg: IIntegrationSetupContext | IConfigFlowContext, configHomeIdArg: string | undefined, workArg: (leaseArg: INativeSetupLease) => Promise<TResult>, runtimeArg: boolean): Promise<TResult>;
+    release(leaseArg: NativeIntegrationLease, scopeArg: INativeScopeState): void;
+    closeScope(scopeArg: INativeScopeState): Promise<void>;
+    close(): Promise<void>;
+    retryCleanup(scopeArg?: INativeScopeState): Promise<void>;
+}
+/** A terminal child scope shares owner home admission and resource capacity. */
+export declare class NativeIntegrationScope {
+    #private;
+    constructor(stateArg: NativeOwnerState, scopeArg: INativeScopeState);
+    admit(contextArg: IConfigFlowContext, configHomeIdArg?: string): INativeAdmissionContext;
+    run<TResult>(contextArg: IConfigFlowContext, configHomeIdArg: string | undefined, workArg: (leaseArg: INativeOperationLease) => Promise<TResult>): Promise<TResult>;
+    close(): Promise<void>;
+    retryCleanup(): Promise<void>;
+}
+/** Owns native admission, in-flight work, runtimes and failed cleanup without replaying transport work. */
+export declare class NativeIntegrationOwner {
+    #private;
+    constructor(domainArg: string, optionsArg?: INativeIntegrationOwnerOptions);
+    get admission(): NativeHomeAdmission;
+    get signal(): AbortSignal;
+    runSetup<TResult>(contextArg: IIntegrationSetupContext, configHomeIdArg: string, workArg: (leaseArg: INativeSetupLease) => Promise<TResult>): Promise<TResult>;
+    createFlowScope(): NativeIntegrationScope;
+    close(): Promise<void>;
+    retryCleanup(): Promise<void>;
+}
+export {};

package/dist_ts/core/classes.nativeintegrationowner.js

@@ -0,0 +1,269 @@
+import { NativeHomeAdmission } from './classes.nativehomeadmission.js';
+const scopeState = () => ({ lifetime: new AbortController(), leases: new Set(), operations: new Set(), closed: false });
+class NativeIntegrationLease {
+    #state;
+    #scope;
+    #runtimeAllowed;
+    #lifetime = new AbortController();
+    #resources = new Set();
+    context;
+    signal;
+    #pending = true;
+    #promoted = false;
+    #closed = false;
+    #closePromise;
+    constructor(stateArg, scopeArg, contextArg, runtimeAllowedArg) {
+        this.#state = stateArg;
+        this.#scope = scopeArg;
+        this.#runtimeAllowed = runtimeAllowedArg;
+        this.context = contextArg;
+        this.signal = AbortSignal.any([stateArg.lifetime.signal, scopeArg.lifetime.signal, this.#lifetime.signal,
+            ...(contextArg.abortSignal ? [contextArg.abortSignal] : [])]);
+        // Abort owns cleanup as well as cancellation; rejected cleanup remains on this retained lease.
+        this.signal.addEventListener('abort', () => { void this.close().catch(() => undefined); }, { once: true });
+    }
+    get promoted() { return this.#promoted; }
+    get weight() { return Math.max(1, [...this.#resources].filter((resource) => resource.status !== 'closed').length); }
+    get failed() { return [...this.#resources].some((resource) => resource.status === 'failed'); }
+    assertOpen() {
+        if (this.#closed || this.#state.closed || this.#scope.closed)
+            throw new Error('Native admission lease is closed.');
+        this.signal.throwIfAborted();
+    }
+    own(cleanupArg) {
+        this.assertOpen();
+        if (typeof cleanupArg !== 'function')
+            throw new TypeError('Native cleanup must be a function.');
+        if ([...this.#resources].filter((resource) => resource.status !== 'closed').length > 0)
+            this.#state.assertCapacity();
+        this.#resources.add({ cleanup: cleanupArg, status: 'idle' });
+    }
+    promoteToRuntime() {
+        this.assertOpen();
+        if (!this.#runtimeAllowed || !this.#pending)
+            throw new Error('Only an admitted pending setup can become a runtime.');
+        if (!this.#resources.size)
+            throw new Error('A native runtime must retain an owned cleanup handle.');
+        this.#promoted = true;
+    }
+    finish() { this.#pending = false; this.#releaseIfClosed(); }
+    close() {
+        if (!this.#closePromise) {
+            this.#closed = true;
+            this.#closePromise = Promise.resolve().then(() => this.#drain(false));
+            this.#lifetime.abort(new Error('Native admission lease is closed.'));
+        }
+        return this.#closePromise;
+    }
+    retryCleanup() { return this.#drain(true); }
+    async #drain(retryArg) {
+        const results = await Promise.allSettled([...this.#resources].map((resource) => {
+            if (retryArg && resource.status === 'failed')
+                resource.promise = undefined;
+            if (!resource.promise) {
+                resource.status = 'pending';
+                resource.promise = Promise.resolve().then(() => resource.cleanup()).then(() => {
+                    resource.status = 'closed';
+                }, (errorArg) => {
+                    resource.status = 'failed';
+                    throw errorArg;
+                });
+            }
+            return resource.promise;
+        }));
+        this.#releaseIfClosed();
+        const failures = results.filter((result) => result.status === 'rejected').map((result) => result.reason);
+        if (failures.length)
+            throw new AggregateError(failures, 'Native resource cleanup failed; handles remain owned for explicit retry.');
+    }
+    #releaseIfClosed() {
+        if (!this.#pending && this.#closed && [...this.#resources].every((resource) => resource.status === 'closed')) {
+            this.#state.release(this, this.#scope);
+        }
+    }
+}
+class NativeOwnerState {
+    admission;
+    lifetime = new AbortController();
+    root = scopeState();
+    #capacity;
+    #leases = new Set();
+    #scopes = new Set([this.root]);
+    closed = false;
+    #closePromise;
+    #retryPromise;
+    constructor(domainArg, optionsArg) {
+        if (!optionsArg || (Object.getPrototypeOf(optionsArg) !== Object.prototype && Object.getPrototypeOf(optionsArg) !== null)) {
+            throw new TypeError('Native owner options must be a plain data object.');
+        }
+        for (const key of Reflect.ownKeys(optionsArg)) {
+            const descriptor = Object.getOwnPropertyDescriptor(optionsArg, key);
+            if ((key !== 'homeId' && key !== 'capacity') || !descriptor || !descriptor.enumerable || !('value' in descriptor)) {
+                throw new TypeError('Native owner options contain an unsupported field or accessor.');
+            }
+        }
+        this.#capacity = optionsArg.capacity ?? 16;
+        if (!Number.isSafeInteger(this.#capacity) || this.#capacity < 1)
+            throw new RangeError('Native owner capacity must be a positive safe integer.');
+        this.admission = new NativeHomeAdmission(domainArg, { homeId: optionsArg.homeId });
+    }
+    assertOpen(scopeArg) {
+        if (this.closed || scopeArg.closed)
+            throw new Error('Native integration owner/scope is closed.');
+    }
+    assertCapacity() {
+        if ([...this.#leases].reduce((count, lease) => count + lease.weight, 0) >= this.#capacity) {
+            throw new Error(`Native integration ownership capacity reached: ${this.#capacity}.`);
+        }
+    }
+    createScope() {
+        this.assertOpen(this.root);
+        if (this.#scopes.size > this.#capacity)
+            throw new Error('Native config-flow scope capacity reached.');
+        const scope = scopeState();
+        this.#scopes.add(scope);
+        return scope;
+    }
+    admit(scopeArg, contextArg, configHomeIdArg) {
+        this.assertOpen(scopeArg);
+        return this.admission.admit(contextArg, configHomeIdArg);
+    }
+    run(scopeArg, contextArg, configHomeIdArg, workArg, runtimeArg) {
+        this.assertOpen(scopeArg);
+        if (typeof workArg !== 'function')
+            throw new TypeError('Native operation must be a function.');
+        if (runtimeArg && typeof configHomeIdArg !== 'string')
+            throw new TypeError('Native setup requires configuration homeId.');
+        this.assertCapacity();
+        const context = this.admission.admit(contextArg, configHomeIdArg);
+        const lease = new NativeIntegrationLease(this, scopeArg, context, runtimeArg);
+        this.#leases.add(lease);
+        scopeArg.leases.add(lease);
+        // Publish ownership and work before invoking any caller callback.
+        const operation = Promise.resolve().then(async () => {
+            try {
+                lease.assertOpen();
+                const result = await workArg(lease);
+                if (runtimeArg) {
+                    // Returning a live runtime is a new admission; a completed flow effect is already accepted.
+                    lease.assertOpen();
+                    if (!lease.promoted)
+                        throw new Error('Native setup must transfer its cleanup lease to the returned runtime.');
+                }
+                if (!runtimeArg)
+                    await lease.close();
+                return result;
+            }
+            catch (errorArg) {
+                try {
+                    await lease.close();
+                }
+                catch (cleanupErrorArg) {
+                    throw new AggregateError([errorArg, cleanupErrorArg], 'Native operation and cleanup failed.');
+                }
+                throw errorArg;
+            }
+            finally {
+                lease.finish();
+            }
+        });
+        scopeArg.operations.add(operation);
+        void operation.then(() => scopeArg.operations.delete(operation), () => scopeArg.operations.delete(operation));
+        return operation;
+    }
+    release(leaseArg, scopeArg) {
+        this.#leases.delete(leaseArg);
+        scopeArg.leases.delete(leaseArg);
+    }
+    closeScope(scopeArg) {
+        if (!scopeArg.closePromise) {
+            scopeArg.closed = true;
+            scopeArg.closePromise = Promise.resolve().then(async () => {
+                await this.#drain([scopeArg]);
+                this.#scopes.delete(scopeArg);
+            });
+            for (const lease of scopeArg.leases)
+                void lease.close().catch(() => undefined);
+            scopeArg.lifetime.abort(new Error('Native config-flow scope is closed.'));
+        }
+        return scopeArg.closePromise;
+    }
+    close() {
+        if (!this.#closePromise) {
+            this.closed = true;
+            for (const scope of this.#scopes)
+                scope.closed = true;
+            this.#closePromise = Promise.resolve().then(() => this.#drain([...this.#scopes]));
+            for (const lease of this.#leases)
+                void lease.close().catch(() => undefined);
+            this.lifetime.abort(new Error('Native integration owner is closed.'));
+            for (const scope of this.#scopes)
+                scope.lifetime.abort(this.lifetime.signal.reason);
+        }
+        return this.#closePromise;
+    }
+    retryCleanup(scopeArg) {
+        const existing = scopeArg ? scopeArg.retryPromise : this.#retryPromise;
+        if (existing)
+            return existing;
+        const retry = Promise.resolve().then(async () => {
+            const leases = [...(scopeArg ? scopeArg.leases : this.#leases)].filter((lease) => lease.failed);
+            const results = await Promise.allSettled(leases.map((lease) => lease.retryCleanup()));
+            const errors = results.filter((result) => result.status === 'rejected').map((result) => result.reason);
+            if (errors.length)
+                throw new AggregateError(errors, 'Explicit native cleanup retry failed.');
+            for (const scope of this.#scopes) {
+                if (scope !== this.root && scope.closed && !scope.leases.size && !scope.operations.size)
+                    this.#scopes.delete(scope);
+            }
+        });
+        if (scopeArg)
+            scopeArg.retryPromise = retry;
+        else
+            this.#retryPromise = retry;
+        const settled = () => { if (scopeArg)
+            scopeArg.retryPromise = undefined;
+        else
+            this.#retryPromise = undefined; };
+        void retry.then(settled, settled);
+        return retry;
+    }
+    async #drain(scopesArg) {
+        const cleanup = scopesArg.flatMap((scope) => [...scope.leases].map((lease) => lease.close()));
+        const operations = scopesArg.flatMap((scope) => [...scope.operations]);
+        const [results] = await Promise.all([Promise.allSettled(cleanup), Promise.allSettled(operations)]);
+        // Operation failures are delivered to their callers; owner close owns joining and cleanup failures.
+        const finalResults = await Promise.allSettled(scopesArg.flatMap((scope) => [...scope.leases].map((lease) => lease.close())));
+        const errors = [...results, ...finalResults].filter((result) => result.status === 'rejected').map((result) => result.reason);
+        if (errors.length)
+            throw new AggregateError([...new Set(errors)], 'Native owner cleanup failed; resources remain retained.');
+    }
+}
+/** A terminal child scope shares owner home admission and resource capacity. */
+export class NativeIntegrationScope {
+    #state;
+    #scope;
+    constructor(stateArg, scopeArg) { this.#state = stateArg; this.#scope = scopeArg; }
+    admit(contextArg, configHomeIdArg) {
+        return this.#state.admit(this.#scope, contextArg, configHomeIdArg);
+    }
+    run(contextArg, configHomeIdArg, workArg) {
+        return this.#state.run(this.#scope, contextArg, configHomeIdArg, workArg, false);
+    }
+    close() { return this.#state.closeScope(this.#scope); }
+    retryCleanup() { return this.#state.retryCleanup(this.#scope); }
+}
+/** Owns native admission, in-flight work, runtimes and failed cleanup without replaying transport work. */
+export class NativeIntegrationOwner {
+    #state;
+    constructor(domainArg, optionsArg = {}) { this.#state = new NativeOwnerState(domainArg, optionsArg); }
+    get admission() { return this.#state.admission; }
+    get signal() { return this.#state.lifetime.signal; }
+    runSetup(contextArg, configHomeIdArg, workArg) {
+        return this.#state.run(this.#state.root, contextArg, configHomeIdArg, workArg, true);
+    }
+    createFlowScope() { return new NativeIntegrationScope(this.#state, this.#state.createScope()); }
+    close() { return this.#state.close(); }
+    retryCleanup() { return this.#state.retryCleanup(); }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.nativeintegrationowner.js","sourceRoot":"","sources":["../../ts/core/classes.nativeintegrationowner.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAkE,MAAM,kCAAkC,CAAC;AAqCvI,MAAM,UAAU,GAAG,GAAsB,EAAE,CAAC,CAAC,EAAE,QAAQ,EAAE,IAAI,eAAe,EAAE,EAAE,MAAM,EAAE,IAAI,GAAG,EAAE,EAAE,UAAU,EAAE,IAAI,GAAG,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,CAAC;AAE3I,MAAM,sBAAsB;IACjB,MAAM,CAAmB;IACzB,MAAM,CAAoB;IAC1B,eAAe,CAAU;IACzB,SAAS,GAAG,IAAI,eAAe,EAAE,CAAC;IAClC,UAAU,GAAG,IAAI,GAAG,EAAmB,CAAC;IACxC,OAAO,CAA0B;IACjC,MAAM,CAAc;IAC7B,QAAQ,GAAG,IAAI,CAAC;IAChB,SAAS,GAAG,KAAK,CAAC;IAClB,OAAO,GAAG,KAAK,CAAC;IAChB,aAAa,CAAiB;IAE9B,YAAY,QAA0B,EAAE,QAA2B,EAAE,UAAmC,EAAE,iBAA0B;QAClI,IAAI,CAAC,MAAM,GAAG,QAAQ,CAAC;QACvB,IAAI,CAAC,MAAM,GAAG,QAAQ,CAAC;QACvB,IAAI,CAAC,eAAe,GAAG,iBAAiB,CAAC;QACzC,IAAI,CAAC,OAAO,GAAG,UAAU,CAAC;QAC1B,IAAI,CAAC,MAAM,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM;YACtG,GAAG,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;QAChE,+FAA+F;QAC/F,IAAI,CAAC,MAAM,CAAC,gBAAgB,CAAC,OAAO,EAAE,GAAG,EAAE,GAAG,KAAK,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;IAC7G,CAAC;IAED,IAAW,QAAQ,KAAc,OAAO,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC;IACzD,IAAW,MAAM,KAAa,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,MAAM,KAAK,QAAQ,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;IACnI,IAAW,MAAM,KAAc,OAAO,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC;IAEvG,UAAU;QACf,IAAI,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM;YAAE,MAAM,IAAI,KAAK,CAAC,mCAAmC,CAAC,CAAC;QACnH,IAAI,CAAC,MAAM,CAAC,cAAc,EAAE,CAAC;IAC/B,CAAC;IAEM,GAAG,CAAC,UAA+B;QACxC,IAAI,CAAC,UAAU,EAAE,CAAC;QAClB,IAAI,OAAO,UAAU,KAAK,UAAU;YAAE,MAAM,IAAI,SAAS,CAAC,oCAAoC,CAAC,CAAC;QAChG,IAAI,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,MAAM,KAAK,QAAQ,CAAC,CAAC,MAAM,GAAG,CAAC;YAAE,IAAI,CAAC,MAAM,CAAC,cAAc,EAAE,CAAC;QACrH,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IAC/D,CAAC;IAEM,gBAAgB;QACrB,IAAI,CAAC,UAAU,EAAE,CAAC;QAClB,IAAI,CAAC,IAAI,CAAC,eAAe,IAAI,CAAC,IAAI,CAAC,QAAQ;YAAE,MAAM,IAAI,KAAK,CAAC,sDAAsD,CAAC,CAAC;QACrH,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI;YAAE,MAAM,IAAI,KAAK,CAAC,uDAAuD,CAAC,CAAC;QACpG,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;IACxB,CAAC;IAEM,MAAM,KAAW,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC,CAAC,IAAI,CAAC,gBAAgB,EAAE,CAAC,CAAC,CAAC;IAElE,KAAK;QACV,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC;YACxB,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;YACpB,IAAI,CAAC,aAAa,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;YACtE,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,mCAAmC,CAAC,CAAC,CAAC;QACvE,CAAC;QACD,OAAO,IAAI,CAAC,aAAa,CAAC;IAC5B,CAAC;IAEM,YAAY,KAAoB,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAElE,KAAK,CAAC,MAAM,CAAC,QAAiB;QAC5B,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,UAAU,CAAC,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE;YAC7E,IAAI,QAAQ,IAAI,QAAQ,CAAC,MAAM,KAAK,QAAQ;gBAAE,QAAQ,CAAC,OAAO,GAAG,SAAS,CAAC;YAC3E,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC;gBACtB,QAAQ,CAAC,MAAM,GAAG,SAAS,CAAC;gBAC5B,QAAQ,CAAC,OAAO,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE;oBAC5E,QAAQ,CAAC,MAAM,GAAG,QAAQ,CAAC;gBAC7B,CAAC,EAAE,CAAC,QAAiB,EAAE,EAAE;oBACvB,QAAQ,CAAC,MAAM,GAAG,QAAQ,CAAC;oBAC3B,MAAM,QAAQ,CAAC;gBACjB,CAAC,CAAC,CAAC;YACL,CAAC;YACD,OAAO,QAAQ,CAAC,OAAO,CAAC;QAC1B,CAAC,CAAC,CAAC,CAAC;QACJ,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACxB,MAAM,QAAQ,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,MAAM,EAAmC,EAAE,CAAC,MAAM,CAAC,MAAM,KAAK,UAAU,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,MAAiB,CAAC,CAAC;QACrJ,IAAI,QAAQ,CAAC,MAAM;YAAE,MAAM,IAAI,cAAc,CAAC,QAAQ,EAAE,0EAA0E,CAAC,CAAC;IACtI,CAAC;IAED,gBAAgB;QACd,IAAI,CAAC,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,OAAO,IAAI,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC,CAAC,KAAK,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,MAAM,KAAK,QAAQ,CAAC,EAAE,CAAC;YAC7G,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;QACzC,CAAC;IACH,CAAC;CACF;AAED,MAAM,gBAAgB;IACX,SAAS,CAAsB;IAC/B,QAAQ,GAAG,IAAI,eAAe,EAAE,CAAC;IACjC,IAAI,GAAG,UAAU,EAAE,CAAC;IACpB,SAAS,CAAS;IAClB,OAAO,GAAG,IAAI,GAAG,EAA0B,CAAC;IAC5C,OAAO,GAAG,IAAI,GAAG,CAAoB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;IAC3D,MAAM,GAAG,KAAK,CAAC;IACf,aAAa,CAAiB;IAC9B,aAAa,CAAiB;IAE9B,YAAY,SAAiB,EAAE,UAA0C;QACvE,IAAI,CAAC,UAAU,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC,UAAU,CAAC,KAAK,MAAM,CAAC,SAAS,IAAI,MAAM,CAAC,cAAc,CAAC,UAAU,CAAC,KAAK,IAAI,CAAC,EAAE,CAAC;YAC1H,MAAM,IAAI,SAAS,CAAC,mDAAmD,CAAC,CAAC;QAC3E,CAAC;QACD,KAAK,MAAM,GAAG,IAAI,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE,CAAC;YAC9C,MAAM,UAAU,GAAG,MAAM,CAAC,wBAAwB,CAAC,UAAU,EAAE,GAAG,CAAC,CAAC;YACpE,IAAI,CAAC,GAAG,KAAK,QAAQ,IAAI,GAAG,KAAK,UAAU,CAAC,IAAI,CAAC,UAAU,IAAI,CAAC,UAAU,CAAC,UAAU,IAAI,CAAC,CAAC,OAAO,IAAI,UAAU,CAAC,EAAE,CAAC;gBAClH,MAAM,IAAI,SAAS,CAAC,gEAAgE,CAAC,CAAC;YACxF,CAAC;QACH,CAAC;QACD,IAAI,CAAC,SAAS,GAAG,UAAU,CAAC,QAAQ,IAAI,EAAE,CAAC;QAC3C,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,IAAI,CAAC,SAAS,GAAG,CAAC;YAAE,MAAM,IAAI,UAAU,CAAC,wDAAwD,CAAC,CAAC;QAChJ,IAAI,CAAC,SAAS,GAAG,IAAI,mBAAmB,CAAC,SAAS,EAAE,EAAE,MAAM,EAAE,UAAU,CAAC,MAAM,EAAE,CAAC,CAAC;IACrF,CAAC;IAEM,UAAU,CAAC,QAA2B;QAC3C,IAAI,IAAI,CAAC,MAAM,IAAI,QAAQ,CAAC,MAAM;YAAE,MAAM,IAAI,KAAK,CAAC,2CAA2C,CAAC,CAAC;IACnG,CAAC;IAEM,cAAc;QACnB,IAAI,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE,CAAC,KAAK,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YAC1F,MAAM,IAAI,KAAK,CAAC,kDAAkD,IAAI,CAAC,SAAS,GAAG,CAAC,CAAC;QACvF,CAAC;IACH,CAAC;IAEM,WAAW;QAChB,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC3B,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC,SAAS;YAAE,MAAM,IAAI,KAAK,CAAC,4CAA4C,CAAC,CAAC;QACtG,MAAM,KAAK,GAAG,UAAU,EAAE,CAAC;QAC3B,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QACxB,OAAO,KAAK,CAAC;IACf,CAAC;IAEM,KAAK,CAAC,QAA2B,EAAE,UAAyD,EAAE,eAAwB;QAC3H,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;QAC1B,OAAO,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,UAAU,EAAE,eAAe,CAAC,CAAC;IAC3D,CAAC;IAEM,GAAG,CAAU,QAA2B,EAAE,UAAyD,EACxG,eAAmC,EAAE,OAA0D,EAAE,UAAmB;QACpH,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;QAC1B,IAAI,OAAO,OAAO,KAAK,UAAU;YAAE,MAAM,IAAI,SAAS,CAAC,sCAAsC,CAAC,CAAC;QAC/F,IAAI,UAAU,IAAI,OAAO,eAAe,KAAK,QAAQ;YAAE,MAAM,IAAI,SAAS,CAAC,6CAA6C,CAAC,CAAC;QAC1H,IAAI,CAAC,cAAc,EAAE,CAAC;QACtB,MAAM,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,UAAU,EAAE,eAAe,CAAC,CAAC;QAClE,MAAM,KAAK,GAAG,IAAI,sBAAsB,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,UAAU,CAAC,CAAC;QAC9E,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QACxB,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QAC3B,kEAAkE;QAClE,MAAM,SAAS,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,IAAI,CAAC,KAAK,IAAI,EAAE;YAClD,IAAI,CAAC;gBACH,KAAK,CAAC,UAAU,EAAE,CAAC;gBACnB,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,KAAK,CAAC,CAAC;gBACpC,IAAI,UAAU,EAAE,CAAC;oBACf,4FAA4F;oBAC5F,KAAK,CAAC,UAAU,EAAE,CAAC;oBACnB,IAAI,CAAC,KAAK,CAAC,QAAQ;wBAAE,MAAM,IAAI,KAAK,CAAC,uEAAuE,CAAC,CAAC;gBAChH,CAAC;gBACD,IAAI,CAAC,UAAU;oBAAE,MAAM,KAAK,CAAC,KAAK,EAAE,CAAC;gBACrC,OAAO,MAAM,CAAC;YAChB,CAAC;YAAC,OAAO,QAAQ,EAAE,CAAC;gBAClB,IAAI,CAAC;oBAAC,MAAM,KAAK,CAAC,KAAK,EAAE,CAAC;gBAAC,CAAC;gBAC5B,OAAO,eAAe,EAAE,CAAC;oBAAC,MAAM,IAAI,cAAc,CAAC,CAAC,QAAQ,EAAE,eAAe,CAAC,EAAE,sCAAsC,CAAC,CAAC;gBAAC,CAAC;gBAC1H,MAAM,QAAQ,CAAC;YACjB,CAAC;oBAAS,CAAC;gBAAC,KAAK,CAAC,MAAM,EAAE,CAAC;YAAC,CAAC;QAC/B,CAAC,CAAC,CAAC;QACH,QAAQ,CAAC,UAAU,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QACnC,KAAK,SAAS,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,QAAQ,CAAC,UAAU,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE,GAAG,EAAE,CAAC,QAAQ,CAAC,UAAU,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC;QAC9G,OAAO,SAAS,CAAC;IACnB,CAAC;IAEM,OAAO,CAAC,QAAgC,EAAE,QAA2B;QAC1E,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QAC9B,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IACnC,CAAC;IAEM,UAAU,CAAC,QAA2B;QAC3C,IAAI,CAAC,QAAQ,CAAC,YAAY,EAAE,CAAC;YAC3B,QAAQ,CAAC,MAAM,GAAG,IAAI,CAAC;YACvB,QAAQ,CAAC,YAAY,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,IAAI,CAAC,KAAK,IAAI,EAAE;gBACxD,MAAM,IAAI,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC;gBAC9B,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;YAChC,CAAC,CAAC,CAAC;YACH,KAAK,MAAM,KAAK,IAAI,QAAQ,CAAC,MAAM;gBAAE,KAAK,KAAK,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;YAC/E,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,qCAAqC,CAAC,CAAC,CAAC;QAC5E,CAAC;QACD,OAAO,QAAQ,CAAC,YAAY,CAAC;IAC/B,CAAC;IAEM,KAAK;QACV,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC;YACxB,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;YACnB,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,OAAO;gBAAE,KAAK,CAAC,MAAM,GAAG,IAAI,CAAC;YACtD,IAAI,CAAC,aAAa,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;YAClF,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,OAAO;gBAAE,KAAK,KAAK,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;YAC5E,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,qCAAqC,CAAC,CAAC,CAAC;YACtE,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,OAAO;gBAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QACtF,CAAC;QACD,OAAO,IAAI,CAAC,aAAa,CAAC;IAC5B,CAAC;IAEM,YAAY,CAAC,QAA4B;QAC9C,MAAM,QAAQ,GAAG,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC;QACvE,IAAI,QAAQ;YAAE,OAAO,QAAQ,CAAC;QAC9B,MAAM,KAAK,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,IAAI,CAAC,KAAK,IAAI,EAAE;YAC9C,MAAM,MAAM,GAAG,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;YAChG,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,UAAU,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,YAAY,EAAE,CAAC,CAAC,CAAC;YACtF,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,MAAM,EAAmC,EAAE,CAAC,MAAM,CAAC,MAAM,KAAK,UAAU,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,MAAiB,CAAC,CAAC;YACnJ,IAAI,MAAM,CAAC,MAAM;gBAAE,MAAM,IAAI,cAAc,CAAC,MAAM,EAAE,uCAAuC,CAAC,CAAC;YAC7F,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;gBACjC,IAAI,KAAK,KAAK,IAAI,CAAC,IAAI,IAAI,KAAK,CAAC,MAAM,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,IAAI;oBAAE,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;YACtH,CAAC;QACH,CAAC,CAAC,CAAC;QACH,IAAI,QAAQ;YAAE,QAAQ,CAAC,YAAY,GAAG,KAAK,CAAC;;YACvC,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC;QAChC,MAAM,OAAO,GAAG,GAAS,EAAE,GAAG,IAAI,QAAQ;YAAE,QAAQ,CAAC,YAAY,GAAG,SAAS,CAAC;;YAAM,IAAI,CAAC,aAAa,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC;QACtH,KAAK,KAAK,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;QAClC,OAAO,KAAK,CAAC;IACf,CAAC;IAED,KAAK,CAAC,MAAM,CAAC,SAA8B;QACzC,MAAM,OAAO,GAAG,SAAS,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;QAC9F,MAAM,UAAU,GAAG,SAAS,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,GAAG,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC;QACvE,MAAM,CAAC,OAAO,CAAC,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;QACnG,oGAAoG;QACpG,MAAM,YAAY,GAAG,MAAM,OAAO,CAAC,UAAU,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC;QAC7H,MAAM,MAAM,GAAG,CAAC,GAAG,OAAO,EAAE,GAAG,YAAY,CAAC,CAAC,MAAM,CAAC,CAAC,MAAM,EAAmC,EAAE,CAAC,MAAM,CAAC,MAAM,KAAK,UAAU,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,MAAiB,CAAC,CAAC;QACzK,IAAI,MAAM,CAAC,MAAM;YAAE,MAAM,IAAI,cAAc,CAAC,CAAC,GAAG,IAAI,GAAG,CAAC,MAAM,CAAC,CAAC,EAAE,yDAAyD,CAAC,CAAC;IAC/H,CAAC;CACF;AAED,gFAAgF;AAChF,MAAM,OAAO,sBAAsB;IACxB,MAAM,CAAmB;IACzB,MAAM,CAAoB;IACnC,YAAY,QAA0B,EAAE,QAA2B,IAAI,IAAI,CAAC,MAAM,GAAG,QAAQ,CAAC,CAAC,IAAI,CAAC,MAAM,GAAG,QAAQ,CAAC,CAAC,CAAC;IACjH,KAAK,CAAC,UAA8B,EAAE,eAAwB;QACnE,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,UAAU,EAAE,eAAe,CAAC,CAAC;IACrE,CAAC;IACM,GAAG,CAAU,UAA8B,EAAE,eAAmC,EACrF,OAA8D;QAC9D,OAAO,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,EAAE,UAAU,EAAE,eAAe,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC;IACnF,CAAC;IACM,KAAK,KAAoB,OAAO,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;IACtE,YAAY,KAAoB,OAAO,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;CACvF;AAED,2GAA2G;AAC3G,MAAM,OAAO,sBAAsB;IACxB,MAAM,CAAmB;IAClC,YAAY,SAAiB,EAAE,UAAU,GAAmC,EAAE,IAAI,IAAI,CAAC,MAAM,GAAG,IAAI,gBAAgB,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC;IAC9I,IAAW,SAAS,KAA0B,OAAO,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC;IAC7E,IAAW,MAAM,KAAkB,OAAO,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC;IACjE,QAAQ,CAAU,UAAoC,EAAE,eAAuB,EACpF,OAA0D;QAC1D,OAAO,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,UAAU,EAAE,eAAe,EAAE,OAAO,EAAE,IAAI,CAAC,CAAC;IACvF,CAAC;IACM,eAAe,KAA6B,OAAO,IAAI,sBAAsB,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,CAAC;IACxH,KAAK,KAAoB,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;IACtD,YAAY,KAAoB,OAAO,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE,CAAC,CAAC,CAAC;CAC5E"}

package/dist_ts/core/classes.runtimemanager.js

@@ -205,4 +205,4 @@ export class IntegrationRuntimeManager {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.runtimemanager.js","sourceRoot":"","sources":["../../ts/core/classes.runtimemanager.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.runtimemanager.js","sourceRoot":"","sources":["../../ts/core/classes.runtimemanager.ts"],"names":[],"mappings":"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"}