agl 1.0.17 → 21.0.2

package/dist_ts/classes.passkeymanager.d.ts

@@ -0,0 +1,34 @@
+import { type IAuthenticationBeginOptions, type IAuthenticationBeginResult, type IAuthenticationFinishOptions, type IAuthenticationResult, type IPasskeyManagerOptions, type ISetupBeginOptions, type ISetupBeginResult, type ISetupFinishOptions } from './interfaces.auth.js';
+export declare class PasskeyManager {
+    private readonly store;
+    private readonly relyingPartyName;
+    private readonly webAuthn;
+    private readonly now;
+    private readonly setupAttemptLimit;
+    private readonly setupAttemptWindowMs;
+    private readonly authenticationAttemptLimitPerPeer;
+    private readonly authenticationAttemptWindowMs;
+    private readonly maxActiveSetupCeremonies;
+    private readonly maxActiveAuthenticationCeremonies;
+    private readonly setupAttemptTimestamps;
+    private readonly authenticationVerificationAttemptTimestamps;
+    private readonly authenticationAttemptTimestampsByPeer;
+    private ceremonyCreationTail;
+    constructor(optionsArg: IPasskeyManagerOptions);
+    getAuthState(): Promise<{
+        state: 'setupRequired' | 'ready';
+        setupCodeExpired: boolean;
+    }>;
+    beginSetup(optionsArg: ISetupBeginOptions): Promise<ISetupBeginResult>;
+    finishSetup(optionsArg: ISetupFinishOptions): Promise<IAuthenticationResult>;
+    preflightSetupFinish(optionsArg: ISetupFinishOptions): Promise<void>;
+    beginAuthentication(optionsArg: IAuthenticationBeginOptions): Promise<IAuthenticationBeginResult>;
+    finishAuthentication(optionsArg: IAuthenticationFinishOptions): Promise<IAuthenticationResult>;
+    preflightAuthenticationFinish(optionsArg: IAuthenticationFinishOptions): Promise<void>;
+    private currentTime;
+    private recordSetupAttempt;
+    private recordAuthenticationAttempt;
+    private assertCeremonyCapacity;
+    private assertConfiguredOrigin;
+    private withCeremonyCreationLock;
+}

package/dist_ts/classes.passkeymanager.js

@@ -0,0 +1,456 @@
+import * as plugins from './plugins.js';
+import { AuthError, } from './interfaces.auth.js';
+const setupCeremonyLifetimeMs = 5 * 60 * 1000;
+const authenticationCeremonyLifetimeMs = 2 * 60 * 1000;
+const maxAuthenticationVerificationAttemptsPerWindow = 128;
+const base64Url32BytePattern = /^[A-Za-z0-9_-]{43}$/;
+const defaultWebAuthn = {
+    generateRegistrationOptions: plugins.simplewebauthnServer.generateRegistrationOptions,
+    verifyRegistrationResponse: plugins.simplewebauthnServer.verifyRegistrationResponse,
+    generateAuthenticationOptions: plugins.simplewebauthnServer.generateAuthenticationOptions,
+    verifyAuthenticationResponse: plugins.simplewebauthnServer.verifyAuthenticationResponse,
+};
+const requirePositiveLimit = (valueArg, labelArg, maximumArg = 10_000) => {
+    if (!Number.isSafeInteger(valueArg) || valueArg < 1 || valueArg > maximumArg) {
+        throw new Error(`${labelArg} must be a positive safe integer no greater than ${maximumArg}.`);
+    }
+    return valueArg;
+};
+const requirePeerId = (peerIdArg) => {
+    if (typeof peerIdArg !== 'string'
+        || peerIdArg.length === 0
+        || peerIdArg.length > 512
+        || peerIdArg.trim() !== peerIdArg) {
+        throw new AuthError('peer_mismatch', 'The connection identity is malformed.');
+    }
+    return peerIdArg;
+};
+const requireOrigin = (originArg) => {
+    if (typeof originArg !== 'string' || originArg.length === 0 || originArg.length > 2048) {
+        throw new AuthError('origin_mismatch', 'The request origin is malformed.');
+    }
+    try {
+        const origin = new URL(originArg);
+        if (origin.origin !== originArg
+            || (origin.protocol !== 'http:' && origin.protocol !== 'https:')
+            || origin.username.length > 0
+            || origin.password.length > 0
+            || origin.pathname !== '/'
+            || origin.search.length > 0
+            || origin.hash.length > 0) {
+            throw new Error('not an origin');
+        }
+    }
+    catch {
+        throw new AuthError('origin_mismatch', 'The request origin is malformed.');
+    }
+    return originArg;
+};
+const requireCeremonyId = (ceremonyIdArg) => {
+    if (typeof ceremonyIdArg !== 'string' || !base64Url32BytePattern.test(ceremonyIdArg)) {
+        throw new AuthError('ceremony_invalid', 'The WebAuthn ceremony identifier is malformed.');
+    }
+    return ceremonyIdArg;
+};
+const randomBase64Url = () => plugins.crypto.randomBytes(32).toString('base64url');
+const base64UrlValuesEqual = (leftArg, rightArg) => {
+    if (!base64Url32BytePattern.test(leftArg) || !base64Url32BytePattern.test(rightArg)) {
+        return false;
+    }
+    const left = Buffer.from(leftArg, 'base64url');
+    const right = Buffer.from(rightArg, 'base64url');
+    return left.byteLength === right.byteLength && plugins.crypto.timingSafeEqual(left, right);
+};
+export class PasskeyManager {
+    store;
+    relyingPartyName;
+    webAuthn;
+    now;
+    setupAttemptLimit;
+    setupAttemptWindowMs;
+    authenticationAttemptLimitPerPeer;
+    authenticationAttemptWindowMs;
+    maxActiveSetupCeremonies;
+    maxActiveAuthenticationCeremonies;
+    setupAttemptTimestamps = [];
+    authenticationVerificationAttemptTimestamps = [];
+    authenticationAttemptTimestampsByPeer = new Map();
+    ceremonyCreationTail = Promise.resolve();
+    constructor(optionsArg) {
+        this.store = optionsArg.store;
+        this.relyingPartyName = optionsArg.relyingPartyName ?? 'Agent Gateway Layer';
+        if (this.relyingPartyName.trim().length === 0 || this.relyingPartyName.length > 128) {
+            throw new Error('relyingPartyName must contain 1-128 characters.');
+        }
+        this.webAuthn = optionsArg.webAuthn ?? defaultWebAuthn;
+        this.now = optionsArg.now ?? (() => new Date());
+        this.setupAttemptLimit = requirePositiveLimit(optionsArg.setupAttemptLimit ?? 10, 'setupAttemptLimit');
+        this.setupAttemptWindowMs = requirePositiveLimit(optionsArg.setupAttemptWindowMs ?? 60_000, 'setupAttemptWindowMs', 24 * 60 * 60 * 1000);
+        this.authenticationAttemptLimitPerPeer = requirePositiveLimit(optionsArg.authenticationAttemptLimitPerPeer ?? 6, 'authenticationAttemptLimitPerPeer');
+        this.authenticationAttemptWindowMs = requirePositiveLimit(optionsArg.authenticationAttemptWindowMs ?? 60_000, 'authenticationAttemptWindowMs', 24 * 60 * 60 * 1000);
+        this.maxActiveSetupCeremonies = requirePositiveLimit(optionsArg.maxActiveSetupCeremonies ?? 16, 'maxActiveSetupCeremonies');
+        this.maxActiveAuthenticationCeremonies = requirePositiveLimit(optionsArg.maxActiveAuthenticationCeremonies ?? 64, 'maxActiveAuthenticationCeremonies');
+    }
+    async getAuthState() {
+        const state = await this.store.getState();
+        return {
+            state: state.authState,
+            setupCodeExpired: state.setup !== null
+                && state.setup.expiresAt.getTime() <= this.currentTime().getTime(),
+        };
+    }
+    async beginSetup(optionsArg) {
+        const peerId = requirePeerId(optionsArg.peerId);
+        const origin = requireOrigin(optionsArg.origin);
+        return this.withCeremonyCreationLock(async () => {
+            const now = this.currentTime();
+            await this.assertCeremonyCapacity('setup', now);
+            const state = await this.store.getState();
+            this.assertConfiguredOrigin(origin, state.config.publicOrigin);
+            // the attempt budget must burn BEFORE the code is checked — a limiter
+            // that only counts correct codes throttles the legitimate operator and
+            // leaves guessing unmetered
+            this.recordSetupAttempt(now);
+            await this.store.assertSetupAuthority(optionsArg.setupCode, undefined, now);
+            if (!state.setup) {
+                throw new AuthError('setup_unavailable', 'Passkey setup is no longer available.');
+            }
+            const registrationOptions = await this.webAuthn.generateRegistrationOptions({
+                rpName: this.relyingPartyName,
+                rpID: state.config.rpId,
+                userName: 'agl',
+                userDisplayName: 'agl',
+                userID: Buffer.from(state.webauthnUserId, 'base64url'),
+                timeout: setupCeremonyLifetimeMs,
+                attestationType: 'none',
+                excludeCredentials: [],
+                authenticatorSelection: {
+                    residentKey: 'required',
+                    requireResidentKey: true,
+                    userVerification: 'required',
+                },
+            });
+            const ceremonyId = randomBase64Url();
+            const expiresAt = new Date(Math.min(now.getTime() + setupCeremonyLifetimeMs, state.setup.expiresAt.getTime()));
+            const ceremony = {
+                id: ceremonyId,
+                kind: 'setup',
+                state: 'pending',
+                peerId,
+                challenge: registrationOptions.challenge,
+                origin,
+                rpId: state.config.rpId,
+                userId: state.webauthnUserId,
+                setupGeneration: state.setup.generation,
+                setupHash: state.setup.hash,
+                createdAt: now,
+                expiresAt,
+            };
+            await this.store.createCeremony(ceremony);
+            return { ceremonyId, options: registrationOptions };
+        });
+    }
+    async finishSetup(optionsArg) {
+        const peerId = requirePeerId(optionsArg.peerId);
+        const origin = requireOrigin(optionsArg.origin);
+        const ceremonyId = requireCeremonyId(optionsArg.ceremonyId);
+        const now = this.currentTime();
+        const stateBefore = await this.store.getState();
+        this.assertConfiguredOrigin(origin, stateBefore.config.publicOrigin);
+        // burn the attempt budget BEFORE consuming the ceremony: an exhausted
+        // budget must reject without destroying a still-valid ceremony, otherwise
+        // the user's authenticator keeps a credential the store never accepted
+        this.recordSetupAttempt(now);
+        const ceremony = await this.store.consumeCeremony({
+            ceremonyId,
+            kind: 'setup',
+            peerId,
+            origin,
+            rpId: stateBefore.config.rpId,
+            userId: stateBefore.webauthnUserId,
+            now,
+        });
+        if (ceremony.kind !== 'setup'
+            || typeof ceremony.setupGeneration !== 'string'
+            || typeof ceremony.setupHash !== 'string') {
+            throw new AuthError('ceremony_invalid', 'The WebAuthn ceremony has the wrong kind.');
+        }
+        const setupCeremony = {
+            ...ceremony,
+            kind: 'setup',
+            setupGeneration: ceremony.setupGeneration,
+            setupHash: ceremony.setupHash,
+        };
+        await this.store.assertSetupAuthority(optionsArg.setupCode, setupCeremony, now);
+        let verification;
+        try {
+            verification = await this.webAuthn.verifyRegistrationResponse({
+                response: optionsArg.response,
+                expectedChallenge: ceremony.challenge,
+                expectedOrigin: ceremony.origin,
+                expectedRPID: ceremony.rpId,
+                requireUserPresence: true,
+                requireUserVerification: true,
+            });
+        }
+        catch (errorArg) {
+            throw new AuthError('verification_failed', 'Passkey registration verification failed.', {
+                cause: errorArg,
+            });
+        }
+        if (!verification.verified
+            || !verification.registrationInfo.userVerified
+            || verification.registrationInfo.credential.id !== optionsArg.response.id) {
+            throw new AuthError('verification_failed', 'Passkey registration verification failed.');
+        }
+        const verifiedCredential = verification.registrationInfo.credential;
+        const storedCredential = {
+            id: verifiedCredential.id,
+            publicKey: Buffer.from(verifiedCredential.publicKey).toString('base64url'),
+            counter: verifiedCredential.counter,
+            transports: [...(verifiedCredential.transports ?? optionsArg.response.response.transports ?? [])],
+            deviceType: verification.registrationInfo.credentialDeviceType,
+            backedUp: verification.registrationInfo.credentialBackedUp,
+            createdAt: now,
+            counterUpdateId: randomBase64Url(),
+        };
+        await this.store.commitFirstCredential(setupCeremony, storedCredential);
+        return { authenticated: true, credentialId: storedCredential.id };
+    }
+    async preflightSetupFinish(optionsArg) {
+        const peerId = requirePeerId(optionsArg.peerId);
+        const origin = requireOrigin(optionsArg.origin);
+        const ceremonyId = requireCeremonyId(optionsArg.ceremonyId);
+        const now = this.currentTime();
+        const state = await this.store.getState();
+        this.assertConfiguredOrigin(origin, state.config.publicOrigin);
+        const ceremony = await this.store.assertPendingCeremony({
+            ceremonyId,
+            kind: 'setup',
+            peerId,
+            origin,
+            rpId: state.config.rpId,
+            userId: state.webauthnUserId,
+            now,
+        });
+        if (ceremony.kind !== 'setup'
+            || typeof ceremony.setupGeneration !== 'string'
+            || typeof ceremony.setupHash !== 'string') {
+            throw new AuthError('ceremony_invalid', 'The WebAuthn ceremony has the wrong kind.');
+        }
+        // preflight is the first place a wrong code arrives in the controller
+        // flow, so it must burn the attempt budget too
+        this.recordSetupAttempt(now);
+        await this.store.assertSetupAuthority(optionsArg.setupCode, {
+            ...ceremony,
+            kind: 'setup',
+            setupGeneration: ceremony.setupGeneration,
+            setupHash: ceremony.setupHash,
+        }, now);
+    }
+    async beginAuthentication(optionsArg) {
+        const peerId = requirePeerId(optionsArg.peerId);
+        const origin = requireOrigin(optionsArg.origin);
+        return this.withCeremonyCreationLock(async () => {
+            const now = this.currentTime();
+            await this.assertCeremonyCapacity('authentication', now);
+            const state = await this.store.getState();
+            this.assertConfiguredOrigin(origin, state.config.publicOrigin);
+            if (state.authState !== 'ready' || state.credentials.length === 0) {
+                throw new AuthError('setup_unavailable', 'Passkey authentication is not configured.');
+            }
+            this.recordAuthenticationAttempt(now, peerId, false);
+            const authenticationOptions = await this.webAuthn.generateAuthenticationOptions({
+                rpID: state.config.rpId,
+                timeout: authenticationCeremonyLifetimeMs,
+                userVerification: 'required',
+            });
+            const ceremonyId = randomBase64Url();
+            const ceremony = {
+                id: ceremonyId,
+                kind: 'authentication',
+                state: 'pending',
+                peerId,
+                challenge: authenticationOptions.challenge,
+                origin,
+                rpId: state.config.rpId,
+                userId: state.webauthnUserId,
+                createdAt: now,
+                expiresAt: new Date(now.getTime() + authenticationCeremonyLifetimeMs),
+            };
+            await this.store.createCeremony(ceremony);
+            return { ceremonyId, options: authenticationOptions };
+        });
+    }
+    async finishAuthentication(optionsArg) {
+        const peerId = requirePeerId(optionsArg.peerId);
+        const origin = requireOrigin(optionsArg.origin);
+        const ceremonyId = requireCeremonyId(optionsArg.ceremonyId);
+        const now = this.currentTime();
+        const state = await this.store.getState();
+        this.assertConfiguredOrigin(origin, state.config.publicOrigin);
+        const ceremony = await this.store.consumeCeremony({
+            ceremonyId,
+            kind: 'authentication',
+            peerId,
+            origin,
+            rpId: state.config.rpId,
+            userId: state.webauthnUserId,
+            now,
+        });
+        if (state.authState !== 'ready' || state.credentials.length === 0) {
+            throw new AuthError('setup_unavailable', 'Passkey authentication is not configured.');
+        }
+        const userHandle = optionsArg.response.response.userHandle;
+        if (typeof userHandle !== 'string'
+            || !base64UrlValuesEqual(userHandle, state.webauthnUserId)) {
+            throw new AuthError('verification_failed', 'The passkey user handle is invalid.');
+        }
+        const credential = state.credentials.find((entry) => entry.id === optionsArg.response.id);
+        if (!credential) {
+            throw new AuthError('credential_not_found', 'The passkey credential is unknown.');
+        }
+        this.recordAuthenticationAttempt(now, peerId, true);
+        let verification;
+        try {
+            verification = await this.webAuthn.verifyAuthenticationResponse({
+                response: optionsArg.response,
+                expectedChallenge: ceremony.challenge,
+                expectedOrigin: ceremony.origin,
+                expectedRPID: ceremony.rpId,
+                credential: {
+                    id: credential.id,
+                    publicKey: Buffer.from(credential.publicKey, 'base64url'),
+                    counter: credential.counter,
+                    transports: [...credential.transports],
+                },
+                requireUserVerification: true,
+                advancedFIDOConfig: {
+                    userVerification: 'required',
+                },
+            });
+        }
+        catch (errorArg) {
+            throw new AuthError('verification_failed', 'Passkey authentication verification failed.', {
+                cause: errorArg,
+            });
+        }
+        if (!verification.verified
+            || !verification.authenticationInfo.userVerified
+            || verification.authenticationInfo.credentialID !== credential.id
+            || verification.authenticationInfo.origin !== ceremony.origin
+            || verification.authenticationInfo.rpID !== ceremony.rpId) {
+            throw new AuthError('verification_failed', 'Passkey authentication verification failed.');
+        }
+        await this.store.updateCounter(credential.id, credential.counter, verification.authenticationInfo.newCounter);
+        return { authenticated: true, credentialId: credential.id };
+    }
+    async preflightAuthenticationFinish(optionsArg) {
+        const peerId = requirePeerId(optionsArg.peerId);
+        const origin = requireOrigin(optionsArg.origin);
+        const ceremonyId = requireCeremonyId(optionsArg.ceremonyId);
+        const now = this.currentTime();
+        const state = await this.store.getState();
+        this.assertConfiguredOrigin(origin, state.config.publicOrigin);
+        if (state.authState !== 'ready' || state.credentials.length === 0) {
+            throw new AuthError('setup_unavailable', 'Passkey authentication is not configured.');
+        }
+        const userHandle = optionsArg.response.response.userHandle;
+        if (typeof userHandle !== 'string'
+            || !base64UrlValuesEqual(userHandle, state.webauthnUserId)) {
+            throw new AuthError('verification_failed', 'The passkey user handle is invalid.');
+        }
+        if (!state.credentials.some((entry) => entry.id === optionsArg.response.id)) {
+            throw new AuthError('credential_not_found', 'The passkey credential is unknown.');
+        }
+        await this.store.assertPendingCeremony({
+            ceremonyId,
+            kind: 'authentication',
+            peerId,
+            origin,
+            rpId: state.config.rpId,
+            userId: state.webauthnUserId,
+            now,
+        });
+    }
+    currentTime() {
+        const now = this.now();
+        if (!(now instanceof Date) || !Number.isFinite(now.getTime())) {
+            throw new Error('The PasskeyManager clock returned an invalid Date.');
+        }
+        return new Date(now);
+    }
+    recordSetupAttempt(nowArg) {
+        const cutoff = nowArg.getTime() - this.setupAttemptWindowMs;
+        while (this.setupAttemptTimestamps.length > 0
+            && this.setupAttemptTimestamps[0] <= cutoff) {
+            this.setupAttemptTimestamps.shift();
+        }
+        if (this.setupAttemptTimestamps.length >= this.setupAttemptLimit) {
+            throw new AuthError('rate_limited', 'Too many setup attempts. Try again later.');
+        }
+        this.setupAttemptTimestamps.push(nowArg.getTime());
+    }
+    recordAuthenticationAttempt(nowArg, peerIdArg, includeGlobalVerificationLimitArg) {
+        const now = nowArg.getTime();
+        const cutoff = now - this.authenticationAttemptWindowMs;
+        while (this.authenticationVerificationAttemptTimestamps.length > 0
+            && this.authenticationVerificationAttemptTimestamps[0] <= cutoff) {
+            this.authenticationVerificationAttemptTimestamps.shift();
+        }
+        for (const [peerId, timestamps] of this.authenticationAttemptTimestampsByPeer) {
+            while (timestamps.length > 0 && timestamps[0] <= cutoff)
+                timestamps.shift();
+            if (timestamps.length === 0)
+                this.authenticationAttemptTimestampsByPeer.delete(peerId);
+        }
+        const peerTimestamps = this.authenticationAttemptTimestampsByPeer.get(peerIdArg) ?? [];
+        if (peerTimestamps.length >= this.authenticationAttemptLimitPerPeer) {
+            throw new AuthError('rate_limited', 'Too many authentication attempts. Try again later.');
+        }
+        if (includeGlobalVerificationLimitArg
+            && this.authenticationVerificationAttemptTimestamps.length
+                >= maxAuthenticationVerificationAttemptsPerWindow) {
+            throw new AuthError('rate_limited', 'Too many passkey verification attempts. Try again later.');
+        }
+        if (peerTimestamps.length === 0
+            && this.authenticationAttemptTimestampsByPeer.size
+                >= this.maxActiveAuthenticationCeremonies * 2) {
+            throw new AuthError('rate_limited', 'Too many authentication peers. Try again later.');
+        }
+        if (includeGlobalVerificationLimitArg) {
+            this.authenticationVerificationAttemptTimestamps.push(now);
+        }
+        peerTimestamps.push(now);
+        this.authenticationAttemptTimestampsByPeer.set(peerIdArg, peerTimestamps);
+    }
+    async assertCeremonyCapacity(kindArg, nowArg) {
+        const maximum = kindArg === 'setup'
+            ? this.maxActiveSetupCeremonies
+            : this.maxActiveAuthenticationCeremonies;
+        const active = await this.store.countActiveCeremonies(kindArg, nowArg);
+        if (active >= maximum) {
+            throw new AuthError('ceremony_limit', `Too many active ${kindArg} ceremonies.`);
+        }
+    }
+    assertConfiguredOrigin(actualArg, expectedArg) {
+        if (actualArg !== expectedArg) {
+            throw new AuthError('origin_mismatch', 'The request origin is not trusted.');
+        }
+    }
+    async withCeremonyCreationLock(functionArg) {
+        const previous = this.ceremonyCreationTail;
+        let release;
+        this.ceremonyCreationTail = new Promise((resolve) => {
+            release = resolve;
+        });
+        await previous;
+        try {
+            return await functionArg();
+        }
+        finally {
+            release();
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.passkeymanager.js","sourceRoot":"","sources":["../../ts/classes.passkeymanager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,cAAc,CAAC;AACxC,OAAO,EACL,SAAS,GAaV,MAAM,sBAAsB,CAAC;AAE9B,MAAM,uBAAuB,GAAG,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC;AAC9C,MAAM,gCAAgC,GAAG,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC;AACvD,MAAM,8CAA8C,GAAG,GAAG,CAAC;AAC3D,MAAM,sBAAsB,GAAG,qBAAqB,CAAC;AAErD,MAAM,eAAe,GAAkC;IACrD,2BAA2B,EAAE,OAAO,CAAC,oBAAoB,CAAC,2BAA2B;IACrF,0BAA0B,EAAE,OAAO,CAAC,oBAAoB,CAAC,0BAA0B;IACnF,6BAA6B,EAAE,OAAO,CAAC,oBAAoB,CAAC,6BAA6B;IACzF,4BAA4B,EAAE,OAAO,CAAC,oBAAoB,CAAC,4BAA4B;CACxF,CAAC;AAEF,MAAM,oBAAoB,GAAG,CAC3B,QAAgB,EAChB,QAAgB,EAChB,UAAU,GAAG,MAAM,EACX,EAAE;IACV,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,QAAQ,CAAC,IAAI,QAAQ,GAAG,CAAC,IAAI,QAAQ,GAAG,UAAU,EAAE,CAAC;QAC7E,MAAM,IAAI,KAAK,CAAC,GAAG,QAAQ,oDAAoD,UAAU,GAAG,CAAC,CAAC;IAChG,CAAC;IACD,OAAO,QAAQ,CAAC;AAClB,CAAC,CAAC;AAEF,MAAM,aAAa,GAAG,CAAC,SAAiB,EAAU,EAAE;IAClD,IACE,OAAO,SAAS,KAAK,QAAQ;WAC1B,SAAS,CAAC,MAAM,KAAK,CAAC;WACtB,SAAS,CAAC,MAAM,GAAG,GAAG;WACtB,SAAS,CAAC,IAAI,EAAE,KAAK,SAAS,EACjC,CAAC;QACD,MAAM,IAAI,SAAS,CAAC,eAAe,EAAE,uCAAuC,CAAC,CAAC;IAChF,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC,CAAC;AAEF,MAAM,aAAa,GAAG,CAAC,SAAiB,EAAU,EAAE;IAClD,IAAI,OAAO,SAAS,KAAK,QAAQ,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,IAAI,SAAS,CAAC,MAAM,GAAG,IAAI,EAAE,CAAC;QACvF,MAAM,IAAI,SAAS,CAAC,iBAAiB,EAAE,kCAAkC,CAAC,CAAC;IAC7E,CAAC;IACD,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,IAAI,GAAG,CAAC,SAAS,CAAC,CAAC;QAClC,IACE,MAAM,CAAC,MAAM,KAAK,SAAS;eACxB,CAAC,MAAM,CAAC,QAAQ,KAAK,OAAO,IAAI,MAAM,CAAC,QAAQ,KAAK,QAAQ,CAAC;eAC7D,MAAM,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC;eAC1B,MAAM,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC;eAC1B,MAAM,CAAC,QAAQ,KAAK,GAAG;eACvB,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC;eACxB,MAAM,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,EACzB,CAAC;YACD,MAAM,IAAI,KAAK,CAAC,eAAe,CAAC,CAAC;QACnC,CAAC;IACH,CAAC;IAAC,MAAM,CAAC;QACP,MAAM,IAAI,SAAS,CAAC,iBAAiB,EAAE,kCAAkC,CAAC,CAAC;IAC7E,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC,CAAC;AAEF,MAAM,iBAAiB,GAAG,CAAC,aAAqB,EAAU,EAAE;IAC1D,IAAI,OAAO,aAAa,KAAK,QAAQ,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,aAAa,CAAC,EAAE,CAAC;QACrF,MAAM,IAAI,SAAS,CAAC,kBAAkB,EAAE,gDAAgD,CAAC,CAAC;IAC5F,CAAC;IACD,OAAO,aAAa,CAAC;AACvB,CAAC,CAAC;AAEF,MAAM,eAAe,GAAG,GAAW,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;AAE3F,MAAM,oBAAoB,GAAG,CAAC,OAAe,EAAE,QAAgB,EAAW,EAAE;IAC1E,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC;QACpF,OAAO,KAAK,CAAC;IACf,CAAC;IACD,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;IAC/C,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC;IACjD,OAAO,IAAI,CAAC,UAAU,KAAK,KAAK,CAAC,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC,eAAe,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;AAC7F,CAAC,CAAC;AAEF,MAAM,OAAO,cAAc;IACR,KAAK,CAAkC;IACvC,gBAAgB,CAAS;IACzB,QAAQ,CAAgC;IACxC,GAAG,CAAa;IAChB,iBAAiB,CAAS;IAC1B,oBAAoB,CAAS;IAC7B,iCAAiC,CAAS;IAC1C,6BAA6B,CAAS;IACtC,wBAAwB,CAAS;IACjC,iCAAiC,CAAS;IAC1C,sBAAsB,GAAa,EAAE,CAAC;IACtC,2CAA2C,GAAa,EAAE,CAAC;IAC3D,qCAAqC,GAAG,IAAI,GAAG,EAAoB,CAAC;IAC7E,oBAAoB,GAAkB,OAAO,CAAC,OAAO,EAAE,CAAC;IAEhE,YAAY,UAAkC;QAC5C,IAAI,CAAC,KAAK,GAAG,UAAU,CAAC,KAAK,CAAC;QAC9B,IAAI,CAAC,gBAAgB,GAAG,UAAU,CAAC,gBAAgB,IAAI,qBAAqB,CAAC;QAC7E,IAAI,IAAI,CAAC,gBAAgB,CAAC,IAAI,EAAE,CAAC,MAAM,KAAK,CAAC,IAAI,IAAI,CAAC,gBAAgB,CAAC,MAAM,GAAG,GAAG,EAAE,CAAC;YACpF,MAAM,IAAI,KAAK,CAAC,iDAAiD,CAAC,CAAC;QACrE,CAAC;QACD,IAAI,CAAC,QAAQ,GAAG,UAAU,CAAC,QAAQ,IAAI,eAAe,CAAC;QACvD,IAAI,CAAC,GAAG,GAAG,UAAU,CAAC,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC;QAChD,IAAI,CAAC,iBAAiB,GAAG,oBAAoB,CAC3C,UAAU,CAAC,iBAAiB,IAAI,EAAE,EAClC,mBAAmB,CACpB,CAAC;QACF,IAAI,CAAC,oBAAoB,GAAG,oBAAoB,CAC9C,UAAU,CAAC,oBAAoB,IAAI,MAAM,EACzC,sBAAsB,EACtB,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CACpB,CAAC;QACF,IAAI,CAAC,iCAAiC,GAAG,oBAAoB,CAC3D,UAAU,CAAC,iCAAiC,IAAI,CAAC,EACjD,mCAAmC,CACpC,CAAC;QACF,IAAI,CAAC,6BAA6B,GAAG,oBAAoB,CACvD,UAAU,CAAC,6BAA6B,IAAI,MAAM,EAClD,+BAA+B,EAC/B,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CACpB,CAAC;QACF,IAAI,CAAC,wBAAwB,GAAG,oBAAoB,CAClD,UAAU,CAAC,wBAAwB,IAAI,EAAE,EACzC,0BAA0B,CAC3B,CAAC;QACF,IAAI,CAAC,iCAAiC,GAAG,oBAAoB,CAC3D,UAAU,CAAC,iCAAiC,IAAI,EAAE,EAClD,mCAAmC,CACpC,CAAC;IACJ,CAAC;IAEM,KAAK,CAAC,YAAY;QAIvB,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC;QAC1C,OAAO;YACL,KAAK,EAAE,KAAK,CAAC,SAAS;YACtB,gBAAgB,EAAE,KAAK,CAAC,KAAK,KAAK,IAAI;mBACjC,KAAK,CAAC,KAAK,CAAC,SAAS,CAAC,OAAO,EAAE,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC,OAAO,EAAE;SACrE,CAAC;IACJ,CAAC;IAEM,KAAK,CAAC,UAAU,CAAC,UAA8B;QACpD,MAAM,MAAM,GAAG,aAAa,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;QAChD,MAAM,MAAM,GAAG,aAAa,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;QAChD,OAAO,IAAI,CAAC,wBAAwB,CAAC,KAAK,IAAI,EAAE;YAC9C,MAAM,GAAG,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;YAC/B,MAAM,IAAI,CAAC,sBAAsB,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;YAChD,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC;YAC1C,IAAI,CAAC,sBAAsB,CAAC,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;YAC/D,sEAAsE;YACtE,uEAAuE;YACvE,4BAA4B;YAC5B,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,CAAC;YAC7B,MAAM,IAAI,CAAC,KAAK,CAAC,oBAAoB,CAAC,UAAU,CAAC,SAAS,EAAE,SAAS,EAAE,GAAG,CAAC,CAAC;YAC5E,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC;gBACjB,MAAM,IAAI,SAAS,CAAC,mBAAmB,EAAE,uCAAuC,CAAC,CAAC;YACpF,CAAC;YAED,MAAM,mBAAmB,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,2BAA2B,CAAC;gBAC1E,MAAM,EAAE,IAAI,CAAC,gBAAgB;gBAC7B,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC,IAAI;gBACvB,QAAQ,EAAE,KAAK;gBACf,eAAe,EAAE,KAAK;gBACtB,MAAM,EAAE,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,cAAc,EAAE,WAAW,CAAC;gBACtD,OAAO,EAAE,uBAAuB;gBAChC,eAAe,EAAE,MAAM;gBACvB,kBAAkB,EAAE,EAAE;gBACtB,sBAAsB,EAAE;oBACtB,WAAW,EAAE,UAAU;oBACvB,kBAAkB,EAAE,IAAI;oBACxB,gBAAgB,EAAE,UAAU;iBAC7B;aACF,CAAC,CAAC;YACH,MAAM,UAAU,GAAG,eAAe,EAAE,CAAC;YACrC,MAAM,SAAS,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,CACjC,GAAG,CAAC,OAAO,EAAE,GAAG,uBAAuB,EACvC,KAAK,CAAC,KAAK,CAAC,SAAS,CAAC,OAAO,EAAE,CAChC,CAAC,CAAC;YACH,MAAM,QAAQ,GAAmC;gBAC/C,EAAE,EAAE,UAAU;gBACd,IAAI,EAAE,OAAO;gBACb,KAAK,EAAE,SAAS;gBAChB,MAAM;gBACN,SAAS,EAAE,mBAAmB,CAAC,SAAS;gBACxC,MAAM;gBACN,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC,IAAI;gBACvB,MAAM,EAAE,KAAK,CAAC,cAAc;gBAC5B,eAAe,EAAE,KAAK,CAAC,KAAK,CAAC,UAAU;gBACvC,SAAS,EAAE,KAAK,CAAC,KAAK,CAAC,IAAI;gBAC3B,SAAS,EAAE,GAAG;gBACd,SAAS;aACV,CAAC;YACF,MAAM,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC;YAC1C,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,mBAAmB,EAAE,CAAC;QACtD,CAAC,CAAC,CAAC;IACL,CAAC;IAEM,KAAK,CAAC,WAAW,CAAC,UAA+B;QACtD,MAAM,MAAM,GAAG,aAAa,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;QAChD,MAAM,MAAM,GAAG,aAAa,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;QAChD,MAAM,UAAU,GAAG,iBAAiB,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC;QAC5D,MAAM,GAAG,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;QAC/B,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC;QAChD,IAAI,CAAC,sBAAsB,CAAC,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;QACrE,sEAAsE;QACtE,0EAA0E;QAC1E,uEAAuE;QACvE,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,CAAC;QAC7B,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,eAAe,CAAC;YAChD,UAAU;YACV,IAAI,EAAE,OAAO;YACb,MAAM;YACN,MAAM;YACN,IAAI,EAAE,WAAW,CAAC,MAAM,CAAC,IAAI;YAC7B,MAAM,EAAE,WAAW,CAAC,cAAc;YAClC,GAAG;SACJ,CAAC,CAAC;QACH,IACE,QAAQ,CAAC,IAAI,KAAK,OAAO;eACtB,OAAO,QAAQ,CAAC,eAAe,KAAK,QAAQ;eAC5C,OAAO,QAAQ,CAAC,SAAS,KAAK,QAAQ,EACzC,CAAC;YACD,MAAM,IAAI,SAAS,CAAC,kBAAkB,EAAE,2CAA2C,CAAC,CAAC;QACvF,CAAC;QACD,MAAM,aAAa,GAAmC;YACpD,GAAG,QAAQ;YACX,IAAI,EAAE,OAAO;YACb,eAAe,EAAE,QAAQ,CAAC,eAAe;YACzC,SAAS,EAAE,QAAQ,CAAC,SAAS;SAC9B,CAAC;QACF,MAAM,IAAI,CAAC,KAAK,CAAC,oBAAoB,CAAC,UAAU,CAAC,SAAS,EAAE,aAAa,EAAE,GAAG,CAAC,CAAC;QAEhF,IAAI,YAEF,CAAC;QACH,IAAI,CAAC;YACH,YAAY,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,0BAA0B,CAAC;gBAC5D,QAAQ,EAAE,UAAU,CAAC,QAAQ;gBAC7B,iBAAiB,EAAE,QAAQ,CAAC,SAAS;gBACrC,cAAc,EAAE,QAAQ,CAAC,MAAM;gBAC/B,YAAY,EAAE,QAAQ,CAAC,IAAI;gBAC3B,mBAAmB,EAAE,IAAI;gBACzB,uBAAuB,EAAE,IAAI;aAC9B,CAAC,CAAC;QACL,CAAC;QAAC,OAAO,QAAQ,EAAE,CAAC;YAClB,MAAM,IAAI,SAAS,CAAC,qBAAqB,EAAE,2CAA2C,EAAE;gBACtF,KAAK,EAAE,QAAQ;aAChB,CAAC,CAAC;QACL,CAAC;QACD,IACE,CAAC,YAAY,CAAC,QAAQ;eACnB,CAAC,YAAY,CAAC,gBAAgB,CAAC,YAAY;eAC3C,YAAY,CAAC,gBAAgB,CAAC,UAAU,CAAC,EAAE,KAAK,UAAU,CAAC,QAAQ,CAAC,EAAE,EACzE,CAAC;YACD,MAAM,IAAI,SAAS,CAAC,qBAAqB,EAAE,2CAA2C,CAAC,CAAC;QAC1F,CAAC;QAED,MAAM,kBAAkB,GAAG,YAAY,CAAC,gBAAgB,CAAC,UAAU,CAAC;QACpE,MAAM,gBAAgB,GAA6B;YACjD,EAAE,EAAE,kBAAkB,CAAC,EAAE;YACzB,SAAS,EAAE,MAAM,CAAC,IAAI,CAAC,kBAAkB,CAAC,SAAS,CAAC,CAAC,QAAQ,CAAC,WAAW,CAAC;YAC1E,OAAO,EAAE,kBAAkB,CAAC,OAAO;YACnC,UAAU,EAAE,CAAC,GAAG,CAAC,kBAAkB,CAAC,UAAU,IAAI,UAAU,CAAC,QAAQ,CAAC,QAAQ,CAAC,UAAU,IAAI,EAAE,CAAC,CAAC;YACjG,UAAU,EAAE,YAAY,CAAC,gBAAgB,CAAC,oBAAoB;YAC9D,QAAQ,EAAE,YAAY,CAAC,gBAAgB,CAAC,kBAAkB;YAC1D,SAAS,EAAE,GAAG;YACd,eAAe,EAAE,eAAe,EAAE;SACnC,CAAC;QACF,MAAM,IAAI,CAAC,KAAK,CAAC,qBAAqB,CAAC,aAAa,EAAE,gBAAgB,CAAC,CAAC;QACxE,OAAO,EAAE,aAAa,EAAE,IAAI,EAAE,YAAY,EAAE,gBAAgB,CAAC,EAAE,EAAE,CAAC;IACpE,CAAC;IAEM,KAAK,CAAC,oBAAoB,CAAC,UAA+B;QAC/D,MAAM,MAAM,GAAG,aAAa,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;QAChD,MAAM,MAAM,GAAG,aAAa,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;QAChD,MAAM,UAAU,GAAG,iBAAiB,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC;QAC5D,MAAM,GAAG,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;QAC/B,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC;QAC1C,IAAI,CAAC,sBAAsB,CAAC,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;QAC/D,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,qBAAqB,CAAC;YACtD,UAAU;YACV,IAAI,EAAE,OAAO;YACb,MAAM;YACN,MAAM;YACN,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC,IAAI;YACvB,MAAM,EAAE,KAAK,CAAC,cAAc;YAC5B,GAAG;SACJ,CAAC,CAAC;QACH,IACE,QAAQ,CAAC,IAAI,KAAK,OAAO;eACtB,OAAO,QAAQ,CAAC,eAAe,KAAK,QAAQ;eAC5C,OAAO,QAAQ,CAAC,SAAS,KAAK,QAAQ,EACzC,CAAC;YACD,MAAM,IAAI,SAAS,CAAC,kBAAkB,EAAE,2CAA2C,CAAC,CAAC;QACvF,CAAC;QACD,sEAAsE;QACtE,+CAA+C;QAC/C,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,CAAC;QAC7B,MAAM,IAAI,CAAC,KAAK,CAAC,oBAAoB,CAAC,UAAU,CAAC,SAAS,EAAE;YAC1D,GAAG,QAAQ;YACX,IAAI,EAAE,OAAO;YACb,eAAe,EAAE,QAAQ,CAAC,eAAe;YACzC,SAAS,EAAE,QAAQ,CAAC,SAAS;SAC9B,EAAE,GAAG,CAAC,CAAC;IACV,CAAC;IAEM,KAAK,CAAC,mBAAmB,CAC9B,UAAuC;QAEvC,MAAM,MAAM,GAAG,aAAa,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;QAChD,MAAM,MAAM,GAAG,aAAa,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;QAChD,OAAO,IAAI,CAAC,wBAAwB,CAAC,KAAK,IAAI,EAAE;YAC9C,MAAM,GAAG,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;YAC/B,MAAM,IAAI,CAAC,sBAAsB,CAAC,gBAAgB,EAAE,GAAG,CAAC,CAAC;YACzD,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC;YAC1C,IAAI,CAAC,sBAAsB,CAAC,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;YAC/D,IAAI,KAAK,CAAC,SAAS,KAAK,OAAO,IAAI,KAAK,CAAC,WAAW,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;gBAClE,MAAM,IAAI,SAAS,CAAC,mBAAmB,EAAE,2CAA2C,CAAC,CAAC;YACxF,CAAC;YACD,IAAI,CAAC,2BAA2B,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;YACrD,MAAM,qBAAqB,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,6BAA6B,CAAC;gBAC9E,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC,IAAI;gBACvB,OAAO,EAAE,gCAAgC;gBACzC,gBAAgB,EAAE,UAAU;aAC7B,CAAC,CAAC;YACH,MAAM,UAAU,GAAG,eAAe,EAAE,CAAC;YACrC,MAAM,QAAQ,GAA8B;gBAC1C,EAAE,EAAE,UAAU;gBACd,IAAI,EAAE,gBAAgB;gBACtB,KAAK,EAAE,SAAS;gBAChB,MAAM;gBACN,SAAS,EAAE,qBAAqB,CAAC,SAAS;gBAC1C,MAAM;gBACN,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC,IAAI;gBACvB,MAAM,EAAE,KAAK,CAAC,cAAc;gBAC5B,SAAS,EAAE,GAAG;gBACd,SAAS,EAAE,IAAI,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,GAAG,gCAAgC,CAAC;aACtE,CAAC;YACF,MAAM,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC;YAC1C,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,qBAAqB,EAAE,CAAC;QACxD,CAAC,CAAC,CAAC;IACL,CAAC;IAEM,KAAK,CAAC,oBAAoB,CAC/B,UAAwC;QAExC,MAAM,MAAM,GAAG,aAAa,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;QAChD,MAAM,MAAM,GAAG,aAAa,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;QAChD,MAAM,UAAU,GAAG,iBAAiB,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC;QAC5D,MAAM,GAAG,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;QAC/B,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC;QAC1C,IAAI,CAAC,sBAAsB,CAAC,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;QAC/D,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,eAAe,CAAC;YAChD,UAAU;YACV,IAAI,EAAE,gBAAgB;YACtB,MAAM;YACN,MAAM;YACN,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC,IAAI;YACvB,MAAM,EAAE,KAAK,CAAC,cAAc;YAC5B,GAAG;SACJ,CAAC,CAAC;QACH,IAAI,KAAK,CAAC,SAAS,KAAK,OAAO,IAAI,KAAK,CAAC,WAAW,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAClE,MAAM,IAAI,SAAS,CAAC,mBAAmB,EAAE,2CAA2C,CAAC,CAAC;QACxF,CAAC;QACD,MAAM,UAAU,GAAG,UAAU,CAAC,QAAQ,CAAC,QAAQ,CAAC,UAAU,CAAC;QAC3D,IACE,OAAO,UAAU,KAAK,QAAQ;eAC3B,CAAC,oBAAoB,CAAC,UAAU,EAAE,KAAK,CAAC,cAAc,CAAC,EAC1D,CAAC;YACD,MAAM,IAAI,SAAS,CAAC,qBAAqB,EAAE,qCAAqC,CAAC,CAAC;QACpF,CAAC;QACD,MAAM,UAAU,GAAG,KAAK,CAAC,WAAW,CAAC,IAAI,CACvC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,KAAK,UAAU,CAAC,QAAQ,CAAC,EAAE,CAC/C,CAAC;QACF,IAAI,CAAC,UAAU,EAAE,CAAC;YAChB,MAAM,IAAI,SAAS,CAAC,sBAAsB,EAAE,oCAAoC,CAAC,CAAC;QACpF,CAAC;QACD,IAAI,CAAC,2BAA2B,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,CAAC;QAEpD,IAAI,YAEF,CAAC;QACH,IAAI,CAAC;YACH,YAAY,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,4BAA4B,CAAC;gBAC9D,QAAQ,EAAE,UAAU,CAAC,QAAQ;gBAC7B,iBAAiB,EAAE,QAAQ,CAAC,SAAS;gBACrC,cAAc,EAAE,QAAQ,CAAC,MAAM;gBAC/B,YAAY,EAAE,QAAQ,CAAC,IAAI;gBAC3B,UAAU,EAAE;oBACV,EAAE,EAAE,UAAU,CAAC,EAAE;oBACjB,SAAS,EAAE,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,SAAS,EAAE,WAAW,CAAC;oBACzD,OAAO,EAAE,UAAU,CAAC,OAAO;oBAC3B,UAAU,EAAE,CAAC,GAAG,UAAU,CAAC,UAAU,CAAC;iBACvC;gBACD,uBAAuB,EAAE,IAAI;gBAC7B,kBAAkB,EAAE;oBAClB,gBAAgB,EAAE,UAAU;iBAC7B;aACF,CAAC,CAAC;QACL,CAAC;QAAC,OAAO,QAAQ,EAAE,CAAC;YAClB,MAAM,IAAI,SAAS,CAAC,qBAAqB,EAAE,6CAA6C,EAAE;gBACxF,KAAK,EAAE,QAAQ;aAChB,CAAC,CAAC;QACL,CAAC;QACD,IACE,CAAC,YAAY,CAAC,QAAQ;eACnB,CAAC,YAAY,CAAC,kBAAkB,CAAC,YAAY;eAC7C,YAAY,CAAC,kBAAkB,CAAC,YAAY,KAAK,UAAU,CAAC,EAAE;eAC9D,YAAY,CAAC,kBAAkB,CAAC,MAAM,KAAK,QAAQ,CAAC,MAAM;eAC1D,YAAY,CAAC,kBAAkB,CAAC,IAAI,KAAK,QAAQ,CAAC,IAAI,EACzD,CAAC;YACD,MAAM,IAAI,SAAS,CAAC,qBAAqB,EAAE,6CAA6C,CAAC,CAAC;QAC5F,CAAC;QACD,MAAM,IAAI,CAAC,KAAK,CAAC,aAAa,CAC5B,UAAU,CAAC,EAAE,EACb,UAAU,CAAC,OAAO,EAClB,YAAY,CAAC,kBAAkB,CAAC,UAAU,CAC3C,CAAC;QACF,OAAO,EAAE,aAAa,EAAE,IAAI,EAAE,YAAY,EAAE,UAAU,CAAC,EAAE,EAAE,CAAC;IAC9D,CAAC;IAEM,KAAK,CAAC,6BAA6B,CACxC,UAAwC;QAExC,MAAM,MAAM,GAAG,aAAa,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;QAChD,MAAM,MAAM,GAAG,aAAa,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;QAChD,MAAM,UAAU,GAAG,iBAAiB,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC;QAC5D,MAAM,GAAG,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;QAC/B,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC;QAC1C,IAAI,CAAC,sBAAsB,CAAC,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;QAC/D,IAAI,KAAK,CAAC,SAAS,KAAK,OAAO,IAAI,KAAK,CAAC,WAAW,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAClE,MAAM,IAAI,SAAS,CAAC,mBAAmB,EAAE,2CAA2C,CAAC,CAAC;QACxF,CAAC;QACD,MAAM,UAAU,GAAG,UAAU,CAAC,QAAQ,CAAC,QAAQ,CAAC,UAAU,CAAC;QAC3D,IACE,OAAO,UAAU,KAAK,QAAQ;eAC3B,CAAC,oBAAoB,CAAC,UAAU,EAAE,KAAK,CAAC,cAAc,CAAC,EAC1D,CAAC;YACD,MAAM,IAAI,SAAS,CAAC,qBAAqB,EAAE,qCAAqC,CAAC,CAAC;QACpF,CAAC;QACD,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,KAAK,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC,EAAE,CAAC;YAC5E,MAAM,IAAI,SAAS,CAAC,sBAAsB,EAAE,oCAAoC,CAAC,CAAC;QACpF,CAAC;QACD,MAAM,IAAI,CAAC,KAAK,CAAC,qBAAqB,CAAC;YACrC,UAAU;YACV,IAAI,EAAE,gBAAgB;YACtB,MAAM;YACN,MAAM;YACN,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC,IAAI;YACvB,MAAM,EAAE,KAAK,CAAC,cAAc;YAC5B,GAAG;SACJ,CAAC,CAAC;IACL,CAAC;IAEO,WAAW;QACjB,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACvB,IAAI,CAAC,CAAC,GAAG,YAAY,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC,EAAE,CAAC;YAC9D,MAAM,IAAI,KAAK,CAAC,oDAAoD,CAAC,CAAC;QACxE,CAAC;QACD,OAAO,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC;IACvB,CAAC;IAEO,kBAAkB,CAAC,MAAY;QACrC,MAAM,MAAM,GAAG,MAAM,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,oBAAoB,CAAC;QAC5D,OACE,IAAI,CAAC,sBAAsB,CAAC,MAAM,GAAG,CAAC;eACnC,IAAI,CAAC,sBAAsB,CAAC,CAAC,CAAC,IAAI,MAAM,EAC3C,CAAC;YACD,IAAI,CAAC,sBAAsB,CAAC,KAAK,EAAE,CAAC;QACtC,CAAC;QACD,IAAI,IAAI,CAAC,sBAAsB,CAAC,MAAM,IAAI,IAAI,CAAC,iBAAiB,EAAE,CAAC;YACjE,MAAM,IAAI,SAAS,CAAC,cAAc,EAAE,2CAA2C,CAAC,CAAC;QACnF,CAAC;QACD,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC,CAAC;IACrD,CAAC;IAEO,2BAA2B,CACjC,MAAY,EACZ,SAAiB,EACjB,iCAA0C;QAE1C,MAAM,GAAG,GAAG,MAAM,CAAC,OAAO,EAAE,CAAC;QAC7B,MAAM,MAAM,GAAG,GAAG,GAAG,IAAI,CAAC,6BAA6B,CAAC;QACxD,OACE,IAAI,CAAC,2CAA2C,CAAC,MAAM,GAAG,CAAC;eACxD,IAAI,CAAC,2CAA2C,CAAC,CAAC,CAAC,IAAI,MAAM,EAChE,CAAC;YACD,IAAI,CAAC,2CAA2C,CAAC,KAAK,EAAE,CAAC;QAC3D,CAAC;QACD,KAAK,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,IAAI,IAAI,CAAC,qCAAqC,EAAE,CAAC;YAC9E,OAAO,UAAU,CAAC,MAAM,GAAG,CAAC,IAAI,UAAU,CAAC,CAAC,CAAC,IAAI,MAAM;gBAAE,UAAU,CAAC,KAAK,EAAE,CAAC;YAC5E,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC;gBAAE,IAAI,CAAC,qCAAqC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QACzF,CAAC;QAED,MAAM,cAAc,GAAG,IAAI,CAAC,qCAAqC,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC;QACvF,IAAI,cAAc,CAAC,MAAM,IAAI,IAAI,CAAC,iCAAiC,EAAE,CAAC;YACpE,MAAM,IAAI,SAAS,CAAC,cAAc,EAAE,oDAAoD,CAAC,CAAC;QAC5F,CAAC;QACD,IACE,iCAAiC;eAC9B,IAAI,CAAC,2CAA2C,CAAC,MAAM;mBACrD,8CAA8C,EACnD,CAAC;YACD,MAAM,IAAI,SAAS,CAAC,cAAc,EAAE,0DAA0D,CAAC,CAAC;QAClG,CAAC;QACD,IACE,cAAc,CAAC,MAAM,KAAK,CAAC;eACxB,IAAI,CAAC,qCAAqC,CAAC,IAAI;mBAC7C,IAAI,CAAC,iCAAiC,GAAG,CAAC,EAC/C,CAAC;YACD,MAAM,IAAI,SAAS,CAAC,cAAc,EAAE,iDAAiD,CAAC,CAAC;QACzF,CAAC;QACD,IAAI,iCAAiC,EAAE,CAAC;YACtC,IAAI,CAAC,2CAA2C,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAC7D,CAAC;QACD,cAAc,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACzB,IAAI,CAAC,qCAAqC,CAAC,GAAG,CAAC,SAAS,EAAE,cAAc,CAAC,CAAC;IAC5E,CAAC;IAEO,KAAK,CAAC,sBAAsB,CAClC,OAAmC,EACnC,MAAY;QAEZ,MAAM,OAAO,GAAG,OAAO,KAAK,OAAO;YACjC,CAAC,CAAC,IAAI,CAAC,wBAAwB;YAC/B,CAAC,CAAC,IAAI,CAAC,iCAAiC,CAAC;QAC3C,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,qBAAqB,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;QACvE,IAAI,MAAM,IAAI,OAAO,EAAE,CAAC;YACtB,MAAM,IAAI,SAAS,CAAC,gBAAgB,EAAE,mBAAmB,OAAO,cAAc,CAAC,CAAC;QAClF,CAAC;IACH,CAAC;IAEO,sBAAsB,CAAC,SAAiB,EAAE,WAAmB;QACnE,IAAI,SAAS,KAAK,WAAW,EAAE,CAAC;YAC9B,MAAM,IAAI,SAAS,CAAC,iBAAiB,EAAE,oCAAoC,CAAC,CAAC;QAC/E,CAAC;IACH,CAAC;IAEO,KAAK,CAAC,wBAAwB,CACpC,WAAmC;QAEnC,MAAM,QAAQ,GAAG,IAAI,CAAC,oBAAoB,CAAC;QAC3C,IAAI,OAAoB,CAAC;QACzB,IAAI,CAAC,oBAAoB,GAAG,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,EAAE;YACxD,OAAO,GAAG,OAAO,CAAC;QACpB,CAAC,CAAC,CAAC;QACH,MAAM,QAAQ,CAAC;QACf,IAAI,CAAC;YACH,OAAO,MAAM,WAAW,EAAE,CAAC;QAC7B,CAAC;gBAAS,CAAC;YACT,OAAO,EAAE,CAAC;QACZ,CAAC;IACH,CAAC;CACF"}

package/dist_ts/classes.processinspection.d.ts

@@ -0,0 +1,50 @@
+export interface IControllerProcessIdentity {
+    pid: number;
+    processGroupId: number;
+    processGroupLeader: boolean;
+    arguments: string[];
+    argumentsTruncated?: boolean;
+    fingerprint: string;
+}
+export interface IControllerProcessCandidate {
+    identity: IControllerProcessIdentity;
+    command: '__serve' | 'foreground';
+    port: number;
+}
+export interface IControllerDataWriterProcessCandidate {
+    kind: 'controller' | 'temp-password' | 'flex-child';
+    identity: IControllerProcessIdentity;
+}
+export declare const readControllerProcessIdentity: (pidArg: number) => Promise<IControllerProcessIdentity | null>;
+export declare const readProcessGroupMemberPids: (processGroupIdArg: number) => Promise<number[]>;
+export declare const processIdentityHasFileArgument: (identityArg: IControllerProcessIdentity, filePathArg: string, optionsArg?: {
+    allowMissingAbsolutePath?: boolean;
+}) => Promise<boolean>;
+export declare const processIdentityHasCliCommand: (identityArg: IControllerProcessIdentity, cliPathArg: string, commandArg: "__serve" | "__upgrade-worker" | "upgrade" | "start" | "foreground" | "temp-password", optionsArg?: {
+    allowMissingAbsolutePath?: boolean;
+}) => Promise<boolean>;
+export declare const listControllerProcessesForCli: (cliPathArg: string) => Promise<IControllerProcessCandidate[]>;
+export declare const listControllerDataWriterProcessesForCli: (cliPathArg: string, optionsArg?: {
+    includeInstalledPackagePaths?: boolean;
+}) => Promise<IControllerDataWriterProcessCandidate[]>;
+export declare const listControllerDataWriterProcessesForCliPaths: (cliPathsArg: readonly string[], optionsArg?: {
+    includeInstalledPackagePaths?: boolean;
+}) => Promise<IControllerDataWriterProcessCandidate[]>;
+export declare const inspectControllerProcess: (optionsArg: {
+    pid: number;
+    cliPath: string;
+    port: number;
+    expectedProcessGroupId?: number;
+    expectedFingerprint?: string;
+    command: "__serve" | "foreground";
+}) => Promise<IControllerProcessIdentity | null>;
+export declare const signalVerifiedControllerProcess: (optionsArg: {
+    pid: number;
+    cliPath: string;
+    port: number;
+    expectedProcessGroupId: number;
+    expectedFingerprint: string;
+    signal: NodeJS.Signals;
+    signalProcessGroup: boolean;
+    command: "__serve" | "foreground";
+}) => Promise<void>;