@nlabs/reaktor 1.16.0 → 1.18.0

package/lib/durableChat/conversations.js

@@ -0,0 +1,729 @@
+/* eslint-disable no-await-in-loop, no-underscore-dangle -- Ordered transactions and Arango identities. */ import { createHash, randomUUID } from 'node:crypto';
+import { ChatError } from './errors.js';
+import { appendChatEvent } from './events.js';
+import { createMembershipAuthorizer, isChatIdentifier } from './membership.js';
+import { createDurableTransaction } from './transaction.js';
+const hash = (input)=>createHash('sha256').update(JSON.stringify(input)).digest('hex');
+const inviteMilliseconds = 7 * 24 * 60 * 60 * 1000;
+const membershipDto = (record)=>({
+        conversationId: record.conversationId,
+        epoch: record.epoch,
+        joinSequence: record.joinSequence,
+        leftSequence: record.leftSequence,
+        personaId: record.personaId,
+        revision: record.revision,
+        role: record.role,
+        state: record.state
+    });
+const inviteDto = (record)=>({
+        conversationId: record.conversationId,
+        expiresAt: record.expiresAt,
+        inviteId: record._key,
+        invitedByPersonaId: record.invitedByPersonaId,
+        revision: record.revision,
+        state: record.state
+    });
+export const createDurableConversationRepository = (context, identity, options)=>{
+    const audience = options.audience || 'mobile';
+    const transact = createDurableTransaction(context, {
+        exclusive: [
+            'chatInvites',
+            'chatOutbox',
+            'chatRateLimits',
+            'chatRequests',
+            'conversations',
+            'hasChatMembership',
+            'hasConversation'
+        ],
+        read: [
+            'hasConnection',
+            'personas',
+            'users',
+            ...options.readCollections || []
+        ]
+    }, options.query);
+    const summary = (conversation, member, audience, includeName = false)=>({
+            activeMemberCount: conversation.activeMemberCount,
+            conversationId: conversation._key,
+            kind: conversation.kind,
+            membership: membershipDto(member),
+            membershipRevision: conversation.membershipRevision,
+            name: includeName ? options.projectName(conversation, audience) : undefined,
+            state: conversation.state
+        });
+    const actor = async (read)=>{
+        const allowed = await read(`LET persona = DOCUMENT('personas', @personaId)
+      LET user = DOCUMENT('users', @userId)
+      RETURN persona != null AND persona.userId == @userId AND persona.active != false
+        AND user != null AND user.active != false`, {
+            ...identity
+        });
+        if (allowed !== true) {
+            throw new ChatError('forbidden');
+        }
+        await adult(read, identity);
+    };
+    const adult = (read, who)=>options.authorizeIdentity(read, who);
+    const connected = async (read, from, personaId)=>{
+        const target = await read(`LET persona = DOCUMENT('personas', @personaId)
+      LET user = DOCUMENT('users', persona.userId)
+      LET following = FIRST(FOR edge IN hasConnection FILTER edge._from == @from AND edge._to == @to
+        AND edge.type == 'follow' AND edge.active != false LIMIT 1 RETURN true)
+      LET followed = FIRST(FOR edge IN hasConnection FILTER edge._to == @from AND edge._from == @to
+        AND edge.type == 'follow' AND edge.active != false LIMIT 1 RETURN true)
+      LET blocked = FIRST(FOR edge IN hasConnection FILTER edge.type == 'block'
+        AND ((edge._from IN [@from, @fromUser] AND edge._to IN [@to, CONCAT('users/', persona.userId)])
+          OR (edge._to IN [@from, @fromUser] AND edge._from IN [@to, CONCAT('users/', persona.userId)])) LIMIT 1 RETURN true)
+      FILTER persona != null AND user != null AND persona.active != false AND user.active != false
+        AND persona.userId != @actorUser AND following == true AND followed == true AND blocked != true
+      RETURN {personaId: @personaId, userId: persona.userId}`, {
+            actorUser: from.userId,
+            from: `personas/${from.personaId}`,
+            fromUser: `users/${from.userId}`,
+            personaId,
+            to: `personas/${personaId}`
+        });
+        if (!target) {
+            throw new ChatError('forbidden');
+        }
+        await adult(read, target);
+        return target;
+    };
+    const conversation = async (read, id)=>{
+        const value = await read('RETURN DOCUMENT("conversations", @id)', {
+            id
+        });
+        if (!value || value.chatSchemaVersion !== 1 || value.state === 'closed') {
+            throw new ChatError('forbidden');
+        }
+        return value;
+    };
+    const member = async (read, conversationId, personaId)=>{
+        const value = await read(`FOR member IN hasChatMembership FILTER member.conversationId == @conversationId
+      AND member.personaId == @personaId AND member.state == 'active' LIMIT 1 RETURN member`, {
+            conversationId,
+            personaId
+        });
+        if (!value) {
+            throw new ChatError('forbidden');
+        }
+        return value;
+    };
+    const access = (read, conversationId, purpose = 'participants')=>createMembershipAuthorizer(read)(identity, {
+            conversationId,
+            purpose
+        });
+    const checkRevision = (entry, expected)=>{
+        if (entry.membershipRevision !== expected || entry.kind !== 'group') {
+            throw new ChatError('conflict');
+        }
+    };
+    const event = async (read, conversationId, epoch, resourceId, revision)=>{
+        await appendChatEvent(read, {
+            actorPersonaId: identity.personaId,
+            conversationId,
+            kind: 'membership.changed',
+            ...epoch ? {
+                membershipEpoch: epoch
+            } : {},
+            resourceId,
+            revision
+        });
+    };
+    const receipt = async (read, action, input)=>{
+        const key = hash([
+            identity.userId,
+            identity.personaId,
+            action,
+            input.idempotencyKey
+        ]);
+        const payloadHash = hash(input);
+        const prior = await read('RETURN DOCUMENT("chatRequests", @key)', {
+            key
+        });
+        if (prior && prior.payloadHash !== payloadHash) {
+            throw new ChatError('conflict');
+        }
+        return {
+            prior: prior?.result,
+            save: (result)=>read('INSERT @record IN chatRequests RETURN true', {
+                    record: {
+                        _key: key,
+                        added: Date.now(),
+                        ownerUserId: identity.userId,
+                        payloadHash,
+                        personaId: identity.personaId,
+                        result
+                    }
+                })
+        };
+    };
+    const rateLimit = async (read)=>{
+        const key = hash([
+            identity.userId,
+            Math.floor(Date.now() / 3600000)
+        ]);
+        const allowed = await read(`LET bucket = DOCUMENT('chatRateLimits', @key)
+      FILTER bucket == null OR bucket.count < 50
+      UPSERT {_key: @key} INSERT {_key: @key, count: 1, userId: @userId} UPDATE {count: OLD.count + 1, userId: @userId}
+      IN chatRateLimits RETURN true`, {
+            key,
+            userId: identity.userId
+        });
+        if (allowed !== true) {
+            throw new ChatError('rate_limited');
+        }
+    };
+    const addMember = async (read, conversationId, who, role, joinSequence)=>{
+        const id = randomUUID();
+        const eventSequence = await read('RETURN DOCUMENT("conversations", @conversationId).lastEventSequence || 0', {
+            conversationId
+        });
+        const record = {
+            _from: `personas/${who.personaId}`,
+            _key: id,
+            _to: `conversations/${conversationId}`,
+            acceptedAt: Date.now(),
+            conversationId,
+            currentKey: `${conversationId}:${who.personaId}`,
+            epoch: randomUUID(),
+            joinEventSequence: joinSequence > 0 ? (eventSequence || 0) + 1 : 0,
+            joinSequence,
+            personaId: who.personaId,
+            revision: 1,
+            role,
+            state: 'active',
+            userId: who.userId
+        };
+        await read('INSERT @record IN hasChatMembership RETURN true', {
+            record
+        });
+        await read(`UPSERT {_from: @from, _to: @to}
+      INSERT {_from: @from, _to: @to, added: @now, conversationId: @conversationId, userId: @userId}
+      UPDATE {} IN hasConversation RETURN true`, {
+            conversationId,
+            from: `users/${who.userId}`,
+            now: Date.now(),
+            to: `conversations/${conversationId}`,
+            userId: who.userId
+        });
+        return record;
+    };
+    const addInvite = async (read, conversationId, who)=>{
+        const id = randomUUID();
+        const record = {
+            _key: id,
+            conversationId,
+            expiresAt: Date.now() + inviteMilliseconds,
+            inviteId: id,
+            invitedByPersonaId: identity.personaId,
+            inviteePersonaId: who.personaId,
+            inviteeUserId: who.userId,
+            revision: 1,
+            state: 'pending'
+        };
+        await read('INSERT @record IN chatInvites RETURN true', {
+            record: {
+                ...record,
+                createdAt: Date.now(),
+                currentKey: `${conversationId}:${who.personaId}`,
+                role: 'member'
+            }
+        });
+        await event(read, conversationId, '', id, 1);
+        return inviteDto(record);
+    };
+    const expireInvites = async (read, conversationId)=>{
+        await read(`FOR invite IN chatInvites FILTER invite.conversationId == @conversationId
+      AND invite.state == 'pending' AND invite.expiresAt <= @now
+      UPDATE invite WITH {currentKey: null, resolvedAt: @now, revision: invite.revision + 1, state: 'expired'}
+      IN chatInvites RETURN true`, {
+            conversationId,
+            now: Date.now()
+        });
+    };
+    const getOrCreateDirect = (input)=>transact(async (read)=>{
+            await actor(read);
+            const target = await connected(read, identity, input.participantPersonaId);
+            const pair = hash([
+                'direct-v1',
+                ...[
+                    identity.personaId,
+                    target.personaId
+                ].sort()
+            ]);
+            const existing = await read('FOR c IN conversations FILTER c.directPairKey == @pair LIMIT 1 RETURN c', {
+                pair
+            });
+            if (existing) {
+                await access(read, existing._key);
+                return summary(existing, await member(read, existing._key, identity.personaId), audience);
+            }
+            await rateLimit(read);
+            const id = `direct-${pair}`;
+            const record = {
+                _key: id,
+                activeMemberCount: 2,
+                chatSchemaVersion: 1,
+                kind: 'direct',
+                lastSequence: 0,
+                membershipRevision: 1,
+                state: 'active'
+            };
+            await read('INSERT @record IN conversations RETURN true', {
+                record: {
+                    ...record,
+                    added: Date.now(),
+                    createdByPersonaId: identity.personaId,
+                    directPairKey: pair,
+                    isDirect: true
+                }
+            });
+            const own = await addMember(read, id, identity, 'member', 0);
+            await addMember(read, id, target, 'member', 0);
+            await event(read, id, own.epoch, id, 1);
+            return summary(record, own, audience);
+        });
+    const createGroup = (input)=>transact(async (read)=>{
+            await actor(read);
+            const request = await receipt(read, 'createGroup', input);
+            if (request.prior) {
+                return request.prior;
+            }
+            await rateLimit(read);
+            const targets = [];
+            for (const personaId of input.memberPersonaIds){
+                targets.push(await connected(read, identity, personaId));
+            }
+            const id = randomUUID();
+            const contentVersion = hash([
+                'group-name',
+                input.name
+            ]);
+            const record = {
+                _key: id,
+                activeMemberCount: 1,
+                chatSchemaVersion: 1,
+                kind: 'group',
+                lastSequence: 0,
+                membershipRevision: 1,
+                name: input.name,
+                nameContentVersion: contentVersion,
+                nameDecision: options.classifyName(input.name, contentVersion),
+                state: 'forming'
+            };
+            await read('INSERT @record IN conversations RETURN true', {
+                record: {
+                    ...record,
+                    added: Date.now(),
+                    createdByPersonaId: identity.personaId,
+                    isDirect: false
+                }
+            });
+            const own = await addMember(read, id, identity, 'owner', 0);
+            for (const target of targets){
+                await addInvite(read, id, target);
+            }
+            await event(read, id, own.epoch, id, 1);
+            const result = summary(record, own, audience);
+            await request.save(result);
+            return result;
+        });
+    const inviteMember = (input)=>transact(async (read)=>{
+            await actor(read);
+            const request = await receipt(read, 'invite', input);
+            if (request.prior) {
+                return request.prior;
+            }
+            const own = await access(read, input.conversationId, 'invite');
+            checkRevision(own, input.expectedRevision);
+            const target = await connected(read, identity, input.personaId);
+            await expireInvites(read, input.conversationId);
+            const prior = await read('FOR invite IN chatInvites FILTER invite.currentKey == @key LIMIT 1 RETURN invite', {
+                key: `${input.conversationId}:${input.personaId}`
+            });
+            if (prior) {
+                const result = inviteDto(prior);
+                await request.save(result);
+                return result;
+            }
+            const counts = await read(`RETURN {
+      active: LENGTH(FOR member IN hasChatMembership FILTER member.conversationId == @conversationId
+        AND member.personaId == @personaId AND member.state == 'active' RETURN 1) > 0,
+      total: LENGTH(FOR member IN hasChatMembership FILTER member.conversationId == @conversationId
+        AND member.state == 'active' RETURN 1) + LENGTH(FOR invite IN chatInvites
+        FILTER invite.conversationId == @conversationId AND invite.state == 'pending' AND invite.expiresAt > @now RETURN 1)
+    }`, {
+                conversationId: input.conversationId,
+                now: Date.now(),
+                personaId: input.personaId
+            });
+            if (!counts || counts.active || counts.total >= 25) {
+                throw new ChatError('conflict');
+            }
+            await rateLimit(read);
+            const result = await addInvite(read, input.conversationId, target);
+            await request.save(result);
+            return result;
+        });
+    const resolveInvite = (input, accept)=>transact(async (read)=>{
+            await actor(read);
+            const request = await receipt(read, accept ? 'accept' : 'decline', input);
+            if (request.prior) {
+                return request.prior;
+            }
+            const invite = await read('RETURN DOCUMENT("chatInvites", @id)', {
+                id: input.inviteId
+            });
+            if (!invite || invite.inviteePersonaId !== identity.personaId || invite.inviteeUserId !== identity.userId || invite.state !== 'pending' || invite.expiresAt <= Date.now()) {
+                throw new ChatError('forbidden');
+            }
+            if (invite.revision !== input.expectedRevision) {
+                throw new ChatError('conflict');
+            }
+            const current = await conversation(read, invite.conversationId);
+            if (current.kind !== 'group') {
+                throw new ChatError('forbidden');
+            }
+            let result;
+            if (accept) {
+                const inviter = await member(read, current._key, invite.invitedByPersonaId);
+                if (![
+                    'owner',
+                    'admin'
+                ].includes(inviter.role) || current.activeMemberCount >= 25) {
+                    throw new ChatError('forbidden');
+                }
+                await adult(read, {
+                    personaId: inviter.personaId,
+                    userId: inviter.userId
+                });
+                await connected(read, {
+                    personaId: inviter.personaId,
+                    userId: inviter.userId
+                }, identity.personaId);
+                const own = await addMember(read, current._key, identity, 'member', current.lastSequence + 1);
+                const updated = await read(`UPDATE @id WITH {
+          activeMemberCount: @count, membershipRevision: @revision, state: @state}
+          IN conversations RETURN NEW`, {
+                    count: current.activeMemberCount + 1,
+                    id: current._key,
+                    revision: current.membershipRevision + 1,
+                    state: current.activeMemberCount + 1 >= 3 ? 'active' : current.state
+                });
+                if (!updated) {
+                    throw new ChatError('unavailable');
+                }
+                await event(read, current._key, own.epoch, own._key, updated.membershipRevision);
+                result = summary(updated, own, audience);
+            } else {
+                result = {
+                    ...inviteDto(invite),
+                    revision: invite.revision + 1,
+                    state: 'declined'
+                };
+                await event(read, current._key, '', invite._key, invite.revision + 1);
+            }
+            await read(`UPDATE @id WITH {currentKey: null, resolvedAt: @now, revision: @revision, state: @state}
+        IN chatInvites RETURN true`, {
+                id: invite._key,
+                now: Date.now(),
+                revision: invite.revision + 1,
+                state: accept ? 'accepted' : 'declined'
+            });
+            await request.save(result);
+            return result;
+        });
+    const changeMembership = (action, input)=>transact(async (read)=>{
+            await actor(read);
+            const request = await receipt(read, action, input);
+            if (request.prior) {
+                return request.prior;
+            }
+            const ownAccess = await access(read, input.conversationId);
+            checkRevision(ownAccess, input.expectedRevision);
+            const current = await conversation(read, input.conversationId);
+            const own = await member(read, current._key, identity.personaId);
+            const targetPersonaId = 'personaId' in input ? input.personaId : identity.personaId;
+            const target = targetPersonaId === identity.personaId ? own : await member(read, current._key, targetPersonaId);
+            const leaving = action === 'leave' || action === 'remove';
+            if ((action === 'role' || action === 'transfer') && (own.role !== 'owner' || target._key === own._key)) {
+                throw new ChatError('forbidden');
+            }
+            if (action === 'remove' && (target._key === own._key || target.role === 'owner' || ![
+                'owner',
+                'admin'
+            ].includes(own.role) || own.role === 'admin' && target.role !== 'member')) {
+                throw new ChatError('forbidden');
+            }
+            if (action === 'leave' && own.role === 'owner' && current.activeMemberCount > 1) {
+                throw new ChatError('conflict');
+            }
+            if (action === 'role' && target.role === 'owner') {
+                throw new ChatError('forbidden');
+            }
+            if (action === 'transfer' || action === 'role' && 'role' in input && input.role === 'admin') {
+                await adult(read, {
+                    personaId: target.personaId,
+                    userId: target.userId
+                });
+            }
+            let ownResult = own;
+            if (action === 'transfer') {
+                await read('UPDATE @id WITH {role: "admin", revision: @revision} IN hasChatMembership RETURN true', {
+                    id: own._key,
+                    revision: own.revision + 1
+                });
+                await read('UPDATE @id WITH {role: "owner", revision: @revision} IN hasChatMembership RETURN true', {
+                    id: target._key,
+                    revision: target.revision + 1
+                });
+                ownResult = {
+                    ...own,
+                    revision: own.revision + 1,
+                    role: 'admin'
+                };
+            } else if (action === 'role' && 'role' in input) {
+                await read('UPDATE @id WITH {role: @role, revision: @revision} IN hasChatMembership RETURN true', {
+                    id: target._key,
+                    revision: target.revision + 1,
+                    role: input.role
+                });
+            } else if (leaving) {
+                const state = action === 'leave' ? 'left' : 'removed';
+                await read(`UPDATE @id WITH {currentKey: null, endedAt: @now, endedByPersonaId: @actor,
+        leftSequence: @sequence, revision: @revision, state: @state} IN hasChatMembership RETURN true`, {
+                    actor: identity.personaId,
+                    id: target._key,
+                    now: Date.now(),
+                    revision: target.revision + 1,
+                    sequence: current.lastSequence,
+                    state
+                });
+                if (action === 'leave') {
+                    ownResult = {
+                        ...own,
+                        leftSequence: current.lastSequence,
+                        revision: own.revision + 1,
+                        state
+                    };
+                }
+                await read(`FOR edge IN hasConversation FILTER edge._from == @from AND edge._to == @to
+        LET remaining = FIRST(FOR member IN hasChatMembership FILTER member.conversationId == @conversationId
+          AND member.userId == @userId AND member.state == 'active' LIMIT 1 RETURN true)
+        FILTER remaining != true REMOVE edge IN hasConversation RETURN true`, {
+                    conversationId: current._key,
+                    from: `users/${target.userId}`,
+                    to: `conversations/${current._key}`,
+                    userId: target.userId
+                });
+            }
+            if (leaving || action === 'role' && 'role' in input && input.role === 'member') {
+                await read(`FOR invite IN chatInvites FILTER invite.conversationId == @conversationId
+        AND invite.state == 'pending' AND (invite.invitedByPersonaId == @personaId OR @close)
+        UPDATE invite WITH {currentKey: null, resolvedAt: @now, revision: invite.revision + 1, state: 'revoked'}
+        IN chatInvites RETURN true`, {
+                    close: leaving && current.activeMemberCount === 1,
+                    conversationId: current._key,
+                    now: Date.now(),
+                    personaId: target.personaId
+                });
+            }
+            const count = current.activeMemberCount - (leaving ? 1 : 0);
+            const updated = await read(`UPDATE @id WITH {
+      activeMemberCount: @count, membershipRevision: @revision, state: @state}
+      IN conversations RETURN NEW`, {
+                count,
+                id: current._key,
+                revision: current.membershipRevision + 1,
+                state: count === 0 ? 'closed' : current.state
+            });
+            if (!updated) {
+                throw new ChatError('unavailable');
+            }
+            await event(read, current._key, target.epoch, target._key, updated.membershipRevision);
+            const result = summary(updated, ownResult, audience);
+            await request.save(result);
+            return result;
+        });
+    const listConversations = (input)=>transact(async (read)=>{
+            await actor(read);
+            const ids = await read(`RETURN (FOR member IN hasChatMembership
+      FILTER member.personaId == @personaId AND member.userId == @userId AND member.state == 'active'
+        AND member.conversationId > @after SORT member.conversationId LIMIT @limit RETURN member.conversationId)`, {
+                ...identity,
+                after: input.after || '',
+                limit: input.limit || 25
+            });
+            const results = [];
+            for (const id of ids || []){
+                try {
+                    await access(read, id);
+                    const current = await conversation(read, id);
+                    if (current.kind === 'direct') {
+                        const peer = await read(`FOR member IN hasChatMembership FILTER member.conversationId == @id
+            AND member.personaId != @personaId AND member.state == 'active' LIMIT 1 RETURN member`, {
+                            id,
+                            personaId: identity.personaId
+                        });
+                        if (!peer) {
+                            continue;
+                        }
+                        await connected(read, identity, peer.personaId);
+                    }
+                    results.push(summary(current, await member(read, id, identity.personaId), audience, true));
+                } catch (error) {
+                    if (!(error instanceof ChatError) || error.code !== 'forbidden') {
+                        throw error;
+                    }
+                }
+            }
+            return results;
+        });
+    const listInvites = (input)=>transact(async (read)=>{
+            await actor(read);
+            const records = await read(`RETURN (FOR invite IN chatInvites
+      FILTER invite.inviteePersonaId == @personaId AND invite.inviteeUserId == @userId AND invite.state == 'pending'
+        AND invite.expiresAt > @now AND invite._key > @after
+      LET conversation = DOCUMENT('conversations', invite.conversationId)
+      LET inviter = DOCUMENT('personas', invite.invitedByPersonaId)
+      LET inviterUser = DOCUMENT('users', inviter.userId)
+      LET inviterMembership = FIRST(FOR member IN hasChatMembership
+        FILTER member.conversationId == invite.conversationId AND member.personaId == invite.invitedByPersonaId
+          AND member.userId == inviter.userId AND member.state == 'active' AND member.role IN ['owner', 'admin']
+        LIMIT 1 RETURN true)
+      LET blocked = FIRST(FOR edge IN hasConnection FILTER edge.type == 'block'
+        AND ((edge._from IN [CONCAT('personas/', @personaId), CONCAT('users/', @userId)]
+          AND edge._to IN [CONCAT('personas/', invite.invitedByPersonaId), CONCAT('users/', inviter.userId)])
+          OR (edge._to IN [CONCAT('personas/', @personaId), CONCAT('users/', @userId)]
+          AND edge._from IN [CONCAT('personas/', invite.invitedByPersonaId), CONCAT('users/', inviter.userId)]))
+        LIMIT 1 RETURN true)
+      FILTER conversation.chatSchemaVersion == 1 AND conversation.state IN ['active', 'forming']
+        AND inviter != null AND inviterUser != null AND inviter.active != false AND inviterUser.active != false
+        AND inviterMembership == true AND blocked != true
+      SORT invite._key LIMIT @limit RETURN invite)`, {
+                ...identity,
+                after: input.after || '',
+                limit: input.limit || 25,
+                now: Date.now()
+            });
+            return (records || []).map(inviteDto);
+        });
+    const getParticipants = (input)=>transact(async (read)=>{
+            await actor(read);
+            await access(read, input.conversationId);
+            const records = await read(`RETURN (FOR member IN hasChatMembership
+        FILTER member.conversationId == @conversationId AND member.state == 'active'
+        LET persona = DOCUMENT('personas', member.personaId) LET user = DOCUMENT('users', member.userId)
+        LET blocked = FIRST(FOR edge IN hasConnection FILTER edge.type == 'block'
+          AND ((edge._from IN [@viewerPersona, @viewerUser]
+            AND edge._to IN [CONCAT('personas/', member.personaId), CONCAT('users/', member.userId)])
+          OR (edge._to IN [@viewerPersona, @viewerUser]
+            AND edge._from IN [CONCAT('personas/', member.personaId), CONCAT('users/', member.userId)])) LIMIT 1 RETURN true)
+        FILTER persona != null AND user != null AND persona.active != false AND user.active != false
+          AND persona.userId == member.userId AND blocked != true
+        SORT member.personaId LIMIT 25 RETURN member)`, {
+                conversationId: input.conversationId,
+                viewerPersona: `personas/${identity.personaId}`,
+                viewerUser: `users/${identity.userId}`
+            });
+            return (records || []).map(membershipDto);
+        });
+    return {
+        acceptInvite: (input)=>resolveInvite(input, true),
+        changeMemberRole: (input)=>changeMembership('role', input),
+        createGroup,
+        declineInvite: (input)=>resolveInvite(input, false),
+        getOrCreateDirect,
+        getParticipants,
+        inviteMember,
+        leaveConversation: (input)=>changeMembership('leave', input),
+        listConversations,
+        listInvites,
+        removeMember: (input)=>changeMembership('remove', input),
+        transferOwnership: (input)=>changeMembership('transfer', input)
+    };
+};
+const valid = (condition)=>{
+    if (!condition) {
+        throw new ChatError('invalid_request');
+    }
+};
+const mutation = (input)=>{
+    valid(Boolean(input) && isChatIdentifier(input.idempotencyKey) && Number.isSafeInteger(input.expectedRevision) && input.expectedRevision > 0);
+};
+const conversationMutation = (input)=>{
+    mutation(input);
+    valid(isChatIdentifier(input.conversationId));
+};
+const targetedMutation = (input)=>{
+    conversationMutation(input);
+    valid(isChatIdentifier(input.personaId));
+};
+const list = (input)=>valid(Boolean(input) && (input.limit === undefined || Number.isSafeInteger(input.limit) && input.limit > 0 && input.limit <= 50) && (input.after === undefined || isChatIdentifier(input.after)));
+export const createDurableConversationActions = (identity, repository)=>{
+    if (!identity || !isChatIdentifier(identity.personaId) || !isChatIdentifier(identity.userId)) {
+        throw new ChatError('forbidden');
+    }
+    return {
+        acceptInvite: async (input)=>{
+            mutation(input);
+            valid(isChatIdentifier(input.inviteId));
+            return repository.acceptInvite(input);
+        },
+        changeMemberRole: async (input)=>{
+            targetedMutation(input);
+            valid([
+                'admin',
+                'member'
+            ].includes(input.role));
+            return repository.changeMemberRole(input);
+        },
+        createGroup: async (input)=>{
+            valid(Boolean(input) && isChatIdentifier(input.idempotencyKey) && typeof input.name === 'string' && input.name.trim().length > 0 && input.name.length <= 200 && Array.isArray(input.memberPersonaIds) && input.memberPersonaIds.length >= 2 && input.memberPersonaIds.length <= 24 && input.memberPersonaIds.every((id)=>isChatIdentifier(id) && id !== identity.personaId) && new Set(input.memberPersonaIds).size === input.memberPersonaIds.length);
+            return repository.createGroup(input);
+        },
+        declineInvite: async (input)=>{
+            mutation(input);
+            valid(isChatIdentifier(input.inviteId));
+            return repository.declineInvite(input);
+        },
+        getOrCreateDirect: async (input)=>{
+            valid(Boolean(input) && isChatIdentifier(input.participantPersonaId) && input.participantPersonaId !== identity.personaId);
+            return repository.getOrCreateDirect(input);
+        },
+        getParticipants: async (input)=>{
+            valid(Boolean(input) && isChatIdentifier(input.conversationId));
+            return repository.getParticipants(input);
+        },
+        inviteMember: async (input)=>{
+            targetedMutation(input);
+            valid(input.personaId !== identity.personaId);
+            return repository.inviteMember(input);
+        },
+        leaveConversation: async (input)=>{
+            conversationMutation(input);
+            return repository.leaveConversation(input);
+        },
+        listConversations: async (input = {})=>{
+            list(input);
+            return repository.listConversations(input);
+        },
+        listInvites: async (input = {})=>{
+            list(input);
+            return repository.listInvites(input);
+        },
+        removeMember: async (input)=>{
+            targetedMutation(input);
+            valid(input.personaId !== identity.personaId);
+            return repository.removeMember(input);
+        },
+        transferOwnership: async (input)=>{
+            targetedMutation(input);
+            valid(input.personaId !== identity.personaId);
+            return repository.transferOwnership(input);
+        }
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/reaktor/packages/reaktor/src/durableChat/conversations.ts"],"sourcesContent":["/* eslint-disable no-await-in-loop, no-underscore-dangle -- Ordered transactions and Arango identities. */\nimport {createHash, randomUUID} from 'node:crypto';\n\nimport {ChatError} from './errors.js';\nimport {appendChatEvent} from './events.js';\nimport {createMembershipAuthorizer, isChatIdentifier} from './membership.js';\nimport {createDurableTransaction} from './transaction.js';\n\nimport type {ApiContext} from '../types/auth.types.js';\nimport type {AuthorizedMembership, ChatIdentity, ChatQuery} from './membership.js';\nimport type {\n  AcceptInviteInput, ChangeMemberRoleInput, ConversationInvite, ConversationMembership,\n  ConversationSummary, CreateDirectInput, CreateGroupInput, InviteMemberInput,\n  LeaveConversationInput, MembershipRole, RemoveMemberInput, TransferOwnershipInput\n} from './types.js';\n\nexport interface ConversationRecord {\n  readonly _key: string;\n  readonly activeMemberCount: number;\n  readonly chatSchemaVersion: number;\n  readonly kind: 'direct' | 'group';\n  readonly lastSequence: number;\n  readonly membershipRevision: number;\n  readonly name?: string;\n  readonly nameContentVersion?: string;\n  readonly nameDecision?: unknown;\n  readonly state: 'active' | 'closed' | 'forming';\n}\ninterface MemberRecord extends ConversationMembership {\n  readonly _key: string;\n  readonly userId: string;\n}\ninterface InviteRecord extends ConversationInvite {\n  readonly _key: string;\n  readonly inviteePersonaId: string;\n  readonly inviteeUserId: string;\n}\nexport interface ChatListInput {\n  readonly after?: string;\n  readonly limit?: number;\n}\nconst hash = (input: unknown): string => createHash('sha256').update(JSON.stringify(input)).digest('hex');\nconst inviteMilliseconds = 7 * 24 * 60 * 60 * 1000;\nconst membershipDto = (record: ConversationMembership): ConversationMembership => ({\n  conversationId: record.conversationId, epoch: record.epoch, joinSequence: record.joinSequence,\n  leftSequence: record.leftSequence, personaId: record.personaId, revision: record.revision,\n  role: record.role, state: record.state\n});\nconst inviteDto = (record: InviteRecord): ConversationInvite => ({\n  conversationId: record.conversationId, expiresAt: record.expiresAt, inviteId: record._key,\n  invitedByPersonaId: record.invitedByPersonaId, revision: record.revision, state: record.state\n});\nexport interface DurableConversationOptions {\n  readonly audience?: 'mobile' | 'web';\n  /** All policy reads must use this query; exceptions fail the transaction. */\n  readonly authorizeIdentity: (read: ChatQuery, identity: ChatIdentity) => Promise<void>;\n  readonly classifyName: (name: string, contentVersion: string) => unknown;\n  readonly projectName: (conversation: ConversationRecord, audience: 'mobile' | 'web') => string | undefined;\n  readonly readCollections?: readonly string[];\n  /** Caller owns transaction/locks/commit when supplied; no independent database access occurs. */\n  readonly query?: ChatQuery;\n}\n\nexport const createDurableConversationRepository = (\n  context: ApiContext, identity: ChatIdentity, options: DurableConversationOptions\n) => {\n  const audience = options.audience || 'mobile';\n  const transact = createDurableTransaction(context, {exclusive: [\n    'chatInvites', 'chatOutbox', 'chatRateLimits', 'chatRequests', 'conversations', 'hasChatMembership', 'hasConversation'\n  ], read: ['hasConnection', 'personas', 'users', ...(options.readCollections || [])]}, options.query);\n  const summary = (conversation: ConversationRecord, member: ConversationMembership,\n    audience: 'mobile' | 'web', includeName = false): ConversationSummary => ({\n    activeMemberCount: conversation.activeMemberCount, conversationId: conversation._key,\n    kind: conversation.kind, membership: membershipDto(member), membershipRevision: conversation.membershipRevision,\n    name: includeName ? options.projectName(conversation, audience) : undefined, state: conversation.state\n  });\n  const actor = async (read: ChatQuery): Promise<void> => {\n    const allowed = await read<boolean>(`LET persona = DOCUMENT('personas', @personaId)\n      LET user = DOCUMENT('users', @userId)\n      RETURN persona != null AND persona.userId == @userId AND persona.active != false\n        AND user != null AND user.active != false`, {...identity});\n    if(allowed !== true) {\n      throw new ChatError('forbidden');\n    }\n    await adult(read, identity);\n  };\n  const adult = (read: ChatQuery, who: ChatIdentity): Promise<void> => options.authorizeIdentity(read, who);\n  const connected = async (read: ChatQuery, from: ChatIdentity, personaId: string): Promise<ChatIdentity> => {\n    const target = await read<ChatIdentity>(`LET persona = DOCUMENT('personas', @personaId)\n      LET user = DOCUMENT('users', persona.userId)\n      LET following = FIRST(FOR edge IN hasConnection FILTER edge._from == @from AND edge._to == @to\n        AND edge.type == 'follow' AND edge.active != false LIMIT 1 RETURN true)\n      LET followed = FIRST(FOR edge IN hasConnection FILTER edge._to == @from AND edge._from == @to\n        AND edge.type == 'follow' AND edge.active != false LIMIT 1 RETURN true)\n      LET blocked = FIRST(FOR edge IN hasConnection FILTER edge.type == 'block'\n        AND ((edge._from IN [@from, @fromUser] AND edge._to IN [@to, CONCAT('users/', persona.userId)])\n          OR (edge._to IN [@from, @fromUser] AND edge._from IN [@to, CONCAT('users/', persona.userId)])) LIMIT 1 RETURN true)\n      FILTER persona != null AND user != null AND persona.active != false AND user.active != false\n        AND persona.userId != @actorUser AND following == true AND followed == true AND blocked != true\n      RETURN {personaId: @personaId, userId: persona.userId}`, {\n      actorUser: from.userId, from: `personas/${from.personaId}`, fromUser: `users/${from.userId}`,\n      personaId, to: `personas/${personaId}`\n    });\n    if(!target) {\n      throw new ChatError('forbidden');\n    }\n    await adult(read, target);\n    return target;\n  };\n  const conversation = async (read: ChatQuery, id: string): Promise<ConversationRecord> => {\n    const value = await read<ConversationRecord>('RETURN DOCUMENT(\"conversations\", @id)', {id});\n    if(!value || value.chatSchemaVersion !== 1 || value.state === 'closed') {\n      throw new ChatError('forbidden');\n    }\n    return value;\n  };\n  const member = async (read: ChatQuery, conversationId: string, personaId: string): Promise<MemberRecord> => {\n    const value = await read<MemberRecord>(`FOR member IN hasChatMembership FILTER member.conversationId == @conversationId\n      AND member.personaId == @personaId AND member.state == 'active' LIMIT 1 RETURN member`, {conversationId, personaId});\n    if(!value) {\n      throw new ChatError('forbidden');\n    }\n    return value;\n  };\n  const access = (read: ChatQuery, conversationId: string, purpose: 'invite' | 'participants' = 'participants') =>\n    createMembershipAuthorizer(read)(identity, {conversationId, purpose});\n  const checkRevision = (entry: AuthorizedMembership, expected: number): void => {\n    if(entry.membershipRevision !== expected || entry.kind !== 'group') {\n      throw new ChatError('conflict');\n    }\n  };\n  const event = async (\n    read: ChatQuery, conversationId: string, epoch: string, resourceId: string, revision: number\n  ) => {\n    await appendChatEvent(read, {actorPersonaId: identity.personaId, conversationId, kind: 'membership.changed',\n      ...(epoch ? {membershipEpoch: epoch} : {}), resourceId, revision});\n  };\n  const receipt = async <T>(read: ChatQuery, action: string, input: {readonly idempotencyKey: string}) => {\n    const key = hash([identity.userId, identity.personaId, action, input.idempotencyKey]);\n    const payloadHash = hash(input);\n    const prior = await read<{readonly payloadHash: string; readonly result: T}>('RETURN DOCUMENT(\"chatRequests\", @key)', {key});\n    if(prior && prior.payloadHash !== payloadHash) {\n      throw new ChatError('conflict');\n    }\n    return {prior: prior?.result, save: (result: T) => read('INSERT @record IN chatRequests RETURN true', {\n      record: {_key: key, added: Date.now(), ownerUserId: identity.userId, payloadHash,\n        personaId: identity.personaId, result}\n    })};\n  };\n  const rateLimit = async (read: ChatQuery): Promise<void> => {\n    const key = hash([identity.userId, Math.floor(Date.now() / 3600000)]);\n    const allowed = await read<boolean>(`LET bucket = DOCUMENT('chatRateLimits', @key)\n      FILTER bucket == null OR bucket.count < 50\n      UPSERT {_key: @key} INSERT {_key: @key, count: 1, userId: @userId} UPDATE {count: OLD.count + 1, userId: @userId}\n      IN chatRateLimits RETURN true`, {key, userId: identity.userId});\n    if(allowed !== true) {\n      throw new ChatError('rate_limited');\n    }\n  };\n  const addMember = async (\n    read: ChatQuery, conversationId: string, who: ChatIdentity, role: MembershipRole, joinSequence: number\n  ): Promise<MemberRecord> => {\n    const id = randomUUID();\n    const eventSequence = await read<number>(\n      'RETURN DOCUMENT(\"conversations\", @conversationId).lastEventSequence || 0', {conversationId});\n    const record = {_from: `personas/${who.personaId}`, _key: id, _to: `conversations/${conversationId}`,\n      acceptedAt: Date.now(), conversationId, currentKey: `${conversationId}:${who.personaId}`, epoch: randomUUID(),\n      joinEventSequence: joinSequence > 0 ? (eventSequence || 0) + 1 : 0, joinSequence, personaId: who.personaId, revision: 1, role, state: 'active' as const, userId: who.userId};\n    await read('INSERT @record IN hasChatMembership RETURN true', {record});\n    await read(`UPSERT {_from: @from, _to: @to}\n      INSERT {_from: @from, _to: @to, added: @now, conversationId: @conversationId, userId: @userId}\n      UPDATE {} IN hasConversation RETURN true`, {\n      conversationId, from: `users/${who.userId}`, now: Date.now(), to: `conversations/${conversationId}`, userId: who.userId\n    });\n    return record;\n  };\n  const addInvite = async (read: ChatQuery, conversationId: string, who: ChatIdentity): Promise<ConversationInvite> => {\n    const id = randomUUID();\n    const record: InviteRecord = {_key: id, conversationId, expiresAt: Date.now() + inviteMilliseconds,\n      inviteId: id, invitedByPersonaId: identity.personaId, inviteePersonaId: who.personaId, inviteeUserId: who.userId, revision: 1, state: 'pending'};\n    await read('INSERT @record IN chatInvites RETURN true', {record: {...record,\n      createdAt: Date.now(), currentKey: `${conversationId}:${who.personaId}`, role: 'member'}});\n    await event(read, conversationId, '', id, 1);\n    return inviteDto(record);\n  };\n  const expireInvites = async (read: ChatQuery, conversationId: string): Promise<void> => {\n    await read(`FOR invite IN chatInvites FILTER invite.conversationId == @conversationId\n      AND invite.state == 'pending' AND invite.expiresAt <= @now\n      UPDATE invite WITH {currentKey: null, resolvedAt: @now, revision: invite.revision + 1, state: 'expired'}\n      IN chatInvites RETURN true`, {conversationId, now: Date.now()});\n  };\n  const getOrCreateDirect = (input: CreateDirectInput): Promise<ConversationSummary> => transact(async (read) => {\n    await actor(read);\n    const target = await connected(read, identity, input.participantPersonaId);\n    const pair = hash(['direct-v1', ...[identity.personaId, target.personaId].sort()]);\n    const existing = await read<ConversationRecord>('FOR c IN conversations FILTER c.directPairKey == @pair LIMIT 1 RETURN c', {pair});\n    if(existing) {\n      await access(read, existing._key);\n      return summary(existing, await member(read, existing._key, identity.personaId), audience);\n    }\n    await rateLimit(read);\n    const id = `direct-${pair}`;\n    const record: ConversationRecord = {_key: id, activeMemberCount: 2, chatSchemaVersion: 1,\n      kind: 'direct', lastSequence: 0, membershipRevision: 1, state: 'active'};\n    await read('INSERT @record IN conversations RETURN true', {record: {...record,\n      added: Date.now(), createdByPersonaId: identity.personaId, directPairKey: pair, isDirect: true}});\n    const own = await addMember(read, id, identity, 'member', 0);\n    await addMember(read, id, target, 'member', 0);\n    await event(read, id, own.epoch, id, 1);\n    return summary(record, own, audience);\n  });\n  const createGroup = (input: CreateGroupInput): Promise<ConversationSummary> => transact(async (read) => {\n    await actor(read);\n    const request = await receipt<ConversationSummary>(read, 'createGroup', input);\n    if(request.prior) {\n      return request.prior;\n    }\n    await rateLimit(read);\n    const targets: ChatIdentity[] = [];\n    for(const personaId of input.memberPersonaIds) {\n      targets.push(await connected(read, identity, personaId));\n    }\n    const id = randomUUID();\n    const contentVersion = hash(['group-name', input.name]);\n    const record: ConversationRecord = {_key: id, activeMemberCount: 1, chatSchemaVersion: 1, kind: 'group',\n      lastSequence: 0, membershipRevision: 1, name: input.name, nameContentVersion: contentVersion,\n      nameDecision: options.classifyName(input.name, contentVersion), state: 'forming'};\n    await read('INSERT @record IN conversations RETURN true', {record: {...record,\n      added: Date.now(), createdByPersonaId: identity.personaId, isDirect: false}});\n    const own = await addMember(read, id, identity, 'owner', 0);\n    for(const target of targets) {\n      await addInvite(read, id, target);\n    }\n    await event(read, id, own.epoch, id, 1);\n    const result = summary(record, own, audience);\n    await request.save(result);\n    return result;\n  });\n  const inviteMember = (input: InviteMemberInput): Promise<ConversationInvite> => transact(async (read) => {\n    await actor(read);\n    const request = await receipt<ConversationInvite>(read, 'invite', input);\n    if(request.prior) {\n      return request.prior;\n    }\n    const own = await access(read, input.conversationId, 'invite');\n    checkRevision(own, input.expectedRevision);\n    const target = await connected(read, identity, input.personaId);\n    await expireInvites(read, input.conversationId);\n    const prior = await read<InviteRecord>('FOR invite IN chatInvites FILTER invite.currentKey == @key LIMIT 1 RETURN invite',\n      {key: `${input.conversationId}:${input.personaId}`});\n    if(prior) {\n      const result = inviteDto(prior);\n      await request.save(result);\n      return result;\n    }\n    const counts = await read<{readonly active: boolean; readonly total: number}>(`RETURN {\n      active: LENGTH(FOR member IN hasChatMembership FILTER member.conversationId == @conversationId\n        AND member.personaId == @personaId AND member.state == 'active' RETURN 1) > 0,\n      total: LENGTH(FOR member IN hasChatMembership FILTER member.conversationId == @conversationId\n        AND member.state == 'active' RETURN 1) + LENGTH(FOR invite IN chatInvites\n        FILTER invite.conversationId == @conversationId AND invite.state == 'pending' AND invite.expiresAt > @now RETURN 1)\n    }`, {conversationId: input.conversationId, now: Date.now(), personaId: input.personaId});\n    if(!counts || counts.active || counts.total >= 25) {\n      throw new ChatError('conflict');\n    }\n    await rateLimit(read);\n    const result = await addInvite(read, input.conversationId, target);\n    await request.save(result);\n    return result;\n  });\n  const resolveInvite = (\n    input: AcceptInviteInput, accept: boolean\n  ): Promise<ConversationSummary | ConversationInvite> =>\n    transact(async (read) => {\n      await actor(read);\n      const request = await receipt<ConversationSummary | ConversationInvite>(read, accept ? 'accept' : 'decline', input);\n      if(request.prior) {\n        return request.prior;\n      }\n      const invite = await read<InviteRecord>('RETURN DOCUMENT(\"chatInvites\", @id)', {id: input.inviteId});\n      if(!invite || invite.inviteePersonaId !== identity.personaId || invite.inviteeUserId !== identity.userId\n        || invite.state !== 'pending' || invite.expiresAt <= Date.now()) {\n        throw new ChatError('forbidden');\n      }\n      if(invite.revision !== input.expectedRevision) {\n        throw new ChatError('conflict');\n      }\n      const current = await conversation(read, invite.conversationId);\n      if(current.kind !== 'group') {\n        throw new ChatError('forbidden');\n      }\n      let result: ConversationSummary | ConversationInvite;\n      if(accept) {\n        const inviter = await member(read, current._key, invite.invitedByPersonaId);\n        if(!['owner', 'admin'].includes(inviter.role) || current.activeMemberCount >= 25) {\n          throw new ChatError('forbidden');\n        }\n        await adult(read, {personaId: inviter.personaId, userId: inviter.userId});\n        await connected(read, {personaId: inviter.personaId, userId: inviter.userId}, identity.personaId);\n        const own = await addMember(read, current._key, identity, 'member', current.lastSequence + 1);\n        const updated = await read<ConversationRecord>(`UPDATE @id WITH {\n          activeMemberCount: @count, membershipRevision: @revision, state: @state}\n          IN conversations RETURN NEW`, {count: current.activeMemberCount + 1, id: current._key,\n          revision: current.membershipRevision + 1,\n          state: current.activeMemberCount + 1 >= 3 ? 'active' : current.state});\n        if(!updated) {\n          throw new ChatError('unavailable');\n        }\n        await event(read, current._key, own.epoch, own._key, updated.membershipRevision);\n        result = summary(updated, own, audience);\n      } else {\n        result = {...inviteDto(invite), revision: invite.revision + 1, state: 'declined'};\n        await event(read, current._key, '', invite._key, invite.revision + 1);\n      }\n      await read(`UPDATE @id WITH {currentKey: null, resolvedAt: @now, revision: @revision, state: @state}\n        IN chatInvites RETURN true`, {id: invite._key, now: Date.now(), revision: invite.revision + 1,\n        state: accept ? 'accepted' : 'declined'});\n      await request.save(result);\n      return result;\n    });\n  const changeMembership = (\n    action: 'leave' | 'remove' | 'role' | 'transfer',\n    input: ChangeMemberRoleInput | LeaveConversationInput | RemoveMemberInput\n  ): Promise<ConversationSummary> => transact(async (read) => {\n    await actor(read);\n    const request = await receipt<ConversationSummary>(read, action, input);\n    if(request.prior) {\n      return request.prior;\n    }\n    const ownAccess = await access(read, input.conversationId);\n    checkRevision(ownAccess, input.expectedRevision);\n    const current = await conversation(read, input.conversationId);\n    const own = await member(read, current._key, identity.personaId);\n    const targetPersonaId = 'personaId' in input ? input.personaId : identity.personaId;\n    const target = targetPersonaId === identity.personaId ? own : await member(read, current._key, targetPersonaId);\n    const leaving = action === 'leave' || action === 'remove';\n    if((action === 'role' || action === 'transfer') && (own.role !== 'owner' || target._key === own._key)) {\n      throw new ChatError('forbidden');\n    }\n    if(action === 'remove' && (target._key === own._key || target.role === 'owner'\n      || !['owner', 'admin'].includes(own.role) || (own.role === 'admin' && target.role !== 'member'))) {\n      throw new ChatError('forbidden');\n    }\n    if(action === 'leave' && own.role === 'owner' && current.activeMemberCount > 1) {\n      throw new ChatError('conflict');\n    }\n    if(action === 'role' && target.role === 'owner') {\n      throw new ChatError('forbidden');\n    }\n    if(action === 'transfer' || (action === 'role' && 'role' in input && input.role === 'admin')) {\n      await adult(read, {personaId: target.personaId, userId: target.userId});\n    }\n    let ownResult = own;\n    if(action === 'transfer') {\n      await read('UPDATE @id WITH {role: \"admin\", revision: @revision} IN hasChatMembership RETURN true',\n        {id: own._key, revision: own.revision + 1});\n      await read('UPDATE @id WITH {role: \"owner\", revision: @revision} IN hasChatMembership RETURN true',\n        {id: target._key, revision: target.revision + 1});\n      ownResult = {...own, revision: own.revision + 1, role: 'admin'};\n    } else if(action === 'role' && 'role' in input) {\n      await read('UPDATE @id WITH {role: @role, revision: @revision} IN hasChatMembership RETURN true',\n        {id: target._key, revision: target.revision + 1, role: input.role});\n    } else if(leaving) {\n      const state = action === 'leave' ? 'left' : 'removed';\n      await read(`UPDATE @id WITH {currentKey: null, endedAt: @now, endedByPersonaId: @actor,\n        leftSequence: @sequence, revision: @revision, state: @state} IN hasChatMembership RETURN true`, {\n        actor: identity.personaId, id: target._key, now: Date.now(), revision: target.revision + 1,\n        sequence: current.lastSequence, state\n      });\n      if(action === 'leave') {\n        ownResult = {...own, leftSequence: current.lastSequence, revision: own.revision + 1, state};\n      }\n      await read(`FOR edge IN hasConversation FILTER edge._from == @from AND edge._to == @to\n        LET remaining = FIRST(FOR member IN hasChatMembership FILTER member.conversationId == @conversationId\n          AND member.userId == @userId AND member.state == 'active' LIMIT 1 RETURN true)\n        FILTER remaining != true REMOVE edge IN hasConversation RETURN true`, {\n        conversationId: current._key, from: `users/${target.userId}`, to: `conversations/${current._key}`, userId: target.userId\n      });\n    }\n    if(leaving || (action === 'role' && 'role' in input && input.role === 'member')) {\n      await read(`FOR invite IN chatInvites FILTER invite.conversationId == @conversationId\n        AND invite.state == 'pending' AND (invite.invitedByPersonaId == @personaId OR @close)\n        UPDATE invite WITH {currentKey: null, resolvedAt: @now, revision: invite.revision + 1, state: 'revoked'}\n        IN chatInvites RETURN true`, {close: leaving && current.activeMemberCount === 1,\n        conversationId: current._key, now: Date.now(), personaId: target.personaId});\n    }\n    const count = current.activeMemberCount - (leaving ? 1 : 0);\n    const updated = await read<ConversationRecord>(`UPDATE @id WITH {\n      activeMemberCount: @count, membershipRevision: @revision, state: @state}\n      IN conversations RETURN NEW`, {count, id: current._key, revision: current.membershipRevision + 1,\n      state: count === 0 ? 'closed' : current.state});\n    if(!updated) {\n      throw new ChatError('unavailable');\n    }\n    await event(read, current._key, target.epoch, target._key, updated.membershipRevision);\n    const result = summary(updated, ownResult, audience);\n    await request.save(result);\n    return result;\n  });\n  const listConversations = (input: ChatListInput): Promise<readonly ConversationSummary[]> =>\n    transact(async (read) => {\n      await actor(read);\n      const ids = await read<string[]>(`RETURN (FOR member IN hasChatMembership\n      FILTER member.personaId == @personaId AND member.userId == @userId AND member.state == 'active'\n        AND member.conversationId > @after SORT member.conversationId LIMIT @limit RETURN member.conversationId)`, {\n        ...identity, after: input.after || '', limit: input.limit || 25\n      });\n      const results: ConversationSummary[] = [];\n      for(const id of ids || []) {\n        try {\n          await access(read, id);\n          const current = await conversation(read, id);\n          if(current.kind === 'direct') {\n            const peer = await read<MemberRecord>(`FOR member IN hasChatMembership FILTER member.conversationId == @id\n            AND member.personaId != @personaId AND member.state == 'active' LIMIT 1 RETURN member`, {id, personaId: identity.personaId});\n            if(!peer) {\n              continue;\n            }\n            await connected(read, identity, peer.personaId);\n          }\n          results.push(summary(current, await member(read, id, identity.personaId), audience, true));\n        } catch(error) {\n          if(!(error instanceof ChatError) || error.code !== 'forbidden') {\n            throw error;\n          }\n        }\n      }\n      return results;\n    });\n  const listInvites = (input: ChatListInput): Promise<readonly ConversationInvite[]> => transact(async (read) => {\n    await actor(read);\n    const records = await read<InviteRecord[]>(`RETURN (FOR invite IN chatInvites\n      FILTER invite.inviteePersonaId == @personaId AND invite.inviteeUserId == @userId AND invite.state == 'pending'\n        AND invite.expiresAt > @now AND invite._key > @after\n      LET conversation = DOCUMENT('conversations', invite.conversationId)\n      LET inviter = DOCUMENT('personas', invite.invitedByPersonaId)\n      LET inviterUser = DOCUMENT('users', inviter.userId)\n      LET inviterMembership = FIRST(FOR member IN hasChatMembership\n        FILTER member.conversationId == invite.conversationId AND member.personaId == invite.invitedByPersonaId\n          AND member.userId == inviter.userId AND member.state == 'active' AND member.role IN ['owner', 'admin']\n        LIMIT 1 RETURN true)\n      LET blocked = FIRST(FOR edge IN hasConnection FILTER edge.type == 'block'\n        AND ((edge._from IN [CONCAT('personas/', @personaId), CONCAT('users/', @userId)]\n          AND edge._to IN [CONCAT('personas/', invite.invitedByPersonaId), CONCAT('users/', inviter.userId)])\n          OR (edge._to IN [CONCAT('personas/', @personaId), CONCAT('users/', @userId)]\n          AND edge._from IN [CONCAT('personas/', invite.invitedByPersonaId), CONCAT('users/', inviter.userId)]))\n        LIMIT 1 RETURN true)\n      FILTER conversation.chatSchemaVersion == 1 AND conversation.state IN ['active', 'forming']\n        AND inviter != null AND inviterUser != null AND inviter.active != false AND inviterUser.active != false\n        AND inviterMembership == true AND blocked != true\n      SORT invite._key LIMIT @limit RETURN invite)`, {...identity, after: input.after || '', limit: input.limit || 25, now: Date.now()});\n    return (records || []).map(inviteDto);\n  });\n  const getParticipants = (input: {readonly conversationId: string}): Promise<readonly ConversationMembership[]> =>\n    transact(async (read) => {\n      await actor(read);\n      await access(read, input.conversationId);\n      const records = await read<MemberRecord[]>(`RETURN (FOR member IN hasChatMembership\n        FILTER member.conversationId == @conversationId AND member.state == 'active'\n        LET persona = DOCUMENT('personas', member.personaId) LET user = DOCUMENT('users', member.userId)\n        LET blocked = FIRST(FOR edge IN hasConnection FILTER edge.type == 'block'\n          AND ((edge._from IN [@viewerPersona, @viewerUser]\n            AND edge._to IN [CONCAT('personas/', member.personaId), CONCAT('users/', member.userId)])\n          OR (edge._to IN [@viewerPersona, @viewerUser]\n            AND edge._from IN [CONCAT('personas/', member.personaId), CONCAT('users/', member.userId)])) LIMIT 1 RETURN true)\n        FILTER persona != null AND user != null AND persona.active != false AND user.active != false\n          AND persona.userId == member.userId AND blocked != true\n        SORT member.personaId LIMIT 25 RETURN member)`, {\n        conversationId: input.conversationId, viewerPersona: `personas/${identity.personaId}`, viewerUser: `users/${identity.userId}`\n      });\n      return (records || []).map(membershipDto);\n    });\n  return {\n    acceptInvite: (input: AcceptInviteInput) => resolveInvite(input, true) as Promise<ConversationSummary>,\n    changeMemberRole: (input: ChangeMemberRoleInput) => changeMembership('role', input),\n    createGroup,\n    declineInvite: (input: AcceptInviteInput) => resolveInvite(input, false) as Promise<ConversationInvite>,\n    getOrCreateDirect, getParticipants, inviteMember,\n    leaveConversation: (input: LeaveConversationInput) => changeMembership('leave', input),\n    listConversations, listInvites,\n    removeMember: (input: RemoveMemberInput) => changeMembership('remove', input),\n    transferOwnership: (input: TransferOwnershipInput) => changeMembership('transfer', input)\n  };\n};\nexport type ChatRepository = ReturnType<typeof createDurableConversationRepository>;\n\nconst valid = (condition: boolean): void => {\n  if(!condition) {\n    throw new ChatError('invalid_request');\n  }\n};\nconst mutation = (input: {readonly expectedRevision: number; readonly idempotencyKey: string}): void => {\n  valid(Boolean(input) && isChatIdentifier(input.idempotencyKey)\n    && Number.isSafeInteger(input.expectedRevision) && input.expectedRevision > 0);\n};\nconst conversationMutation = (input: LeaveConversationInput): void => {\n  mutation(input);\n  valid(isChatIdentifier(input.conversationId));\n};\nconst targetedMutation = (input: RemoveMemberInput): void => {\n  conversationMutation(input);\n  valid(isChatIdentifier(input.personaId));\n};\nconst list = (input: ChatListInput): void => valid(Boolean(input)\n  && (input.limit === undefined || (Number.isSafeInteger(input.limit) && input.limit > 0 && input.limit <= 50))\n  && (input.after === undefined || isChatIdentifier(input.after)));\n\nexport const createDurableConversationActions = (\n  identity: ChatIdentity, repository: ChatRepository\n) => {\n  if(!identity || !isChatIdentifier(identity.personaId) || !isChatIdentifier(identity.userId)) {\n    throw new ChatError('forbidden');\n  }\n  return {\n    acceptInvite: async (input: AcceptInviteInput) => {\n      mutation(input);\n      valid(isChatIdentifier(input.inviteId));\n      return repository.acceptInvite(input);\n    },\n    changeMemberRole: async (input: ChangeMemberRoleInput) => {\n      targetedMutation(input);\n      valid(['admin', 'member'].includes(input.role));\n      return repository.changeMemberRole(input);\n    },\n    createGroup: async (input: CreateGroupInput) => {\n      valid(Boolean(input) && isChatIdentifier(input.idempotencyKey) && typeof input.name === 'string'\n        && input.name.trim().length > 0 && input.name.length <= 200\n        && Array.isArray(input.memberPersonaIds)\n        && input.memberPersonaIds.length >= 2 && input.memberPersonaIds.length <= 24\n        && input.memberPersonaIds.every((id) => isChatIdentifier(id) && id !== identity.personaId)\n        && new Set(input.memberPersonaIds).size === input.memberPersonaIds.length);\n      return repository.createGroup(input);\n    },\n    declineInvite: async (input: AcceptInviteInput) => {\n      mutation(input);\n      valid(isChatIdentifier(input.inviteId));\n      return repository.declineInvite(input);\n    },\n    getOrCreateDirect: async (input: CreateDirectInput) => {\n      valid(Boolean(input) && isChatIdentifier(input.participantPersonaId)\n        && input.participantPersonaId !== identity.personaId);\n      return repository.getOrCreateDirect(input);\n    },\n    getParticipants: async (input: {readonly conversationId: string}) => {\n      valid(Boolean(input) && isChatIdentifier(input.conversationId));\n      return repository.getParticipants(input);\n    },\n    inviteMember: async (input: InviteMemberInput) => {\n      targetedMutation(input);\n      valid(input.personaId !== identity.personaId);\n      return repository.inviteMember(input);\n    },\n    leaveConversation: async (input: LeaveConversationInput) => {\n      conversationMutation(input);\n      return repository.leaveConversation(input);\n    },\n    listConversations: async (input: ChatListInput = {}) => {\n      list(input);\n      return repository.listConversations(input);\n    },\n    listInvites: async (input: ChatListInput = {}) => {\n      list(input);\n      return repository.listInvites(input);\n    },\n    removeMember: async (input: RemoveMemberInput) => {\n      targetedMutation(input);\n      valid(input.personaId !== identity.personaId);\n      return repository.removeMember(input);\n    },\n    transferOwnership: async (input: TransferOwnershipInput) => {\n      targetedMutation(input);\n      valid(input.personaId !== identity.personaId);\n      return repository.transferOwnership(input);\n    }\n  };\n};\n"],"names":["createHash","randomUUID","ChatError","appendChatEvent","createMembershipAuthorizer","isChatIdentifier","createDurableTransaction","hash","input","update","JSON","stringify","digest","inviteMilliseconds","membershipDto","record","conversationId","epoch","joinSequence","leftSequence","personaId","revision","role","state","inviteDto","expiresAt","inviteId","_key","invitedByPersonaId","createDurableConversationRepository","context","identity","options","audience","transact","exclusive","read","readCollections","query","summary","conversation","member","includeName","activeMemberCount","kind","membership","membershipRevision","name","projectName","undefined","actor","allowed","adult","who","authorizeIdentity","connected","from","target","actorUser","userId","fromUser","to","id","value","chatSchemaVersion","access","purpose","checkRevision","entry","expected","event","resourceId","actorPersonaId","membershipEpoch","receipt","action","key","idempotencyKey","payloadHash","prior","result","save","added","Date","now","ownerUserId","rateLimit","Math","floor","addMember","eventSequence","_from","_to","acceptedAt","currentKey","joinEventSequence","addInvite","inviteePersonaId","inviteeUserId","createdAt","expireInvites","getOrCreateDirect","participantPersonaId","pair","sort","existing","lastSequence","createdByPersonaId","directPairKey","isDirect","own","createGroup","request","targets","memberPersonaIds","push","contentVersion","nameContentVersion","nameDecision","classifyName","inviteMember","expectedRevision","counts","active","total","resolveInvite","accept","invite","current","inviter","includes","updated","count","changeMembership","ownAccess","targetPersonaId","leaving","ownResult","sequence","close","listConversations","ids","after","limit","results","peer","error","code","listInvites","records","map","getParticipants","viewerPersona","viewerUser","acceptInvite","changeMemberRole","declineInvite","leaveConversation","removeMember","transferOwnership","valid","condition","mutation","Boolean","Number","isSafeInteger","conversationMutation","targetedMutation","list","createDurableConversationActions","repository","trim","length","Array","isArray","every","Set","size"],"mappings":"AAAA,wGAAwG,GACxG,SAAQA,UAAU,EAAEC,UAAU,QAAO,cAAc;AAEnD,SAAQC,SAAS,QAAO,cAAc;AACtC,SAAQC,eAAe,QAAO,cAAc;AAC5C,SAAQC,0BAA0B,EAAEC,gBAAgB,QAAO,kBAAkB;AAC7E,SAAQC,wBAAwB,QAAO,mBAAmB;AAmC1D,MAAMC,OAAO,CAACC,QAA2BR,WAAW,UAAUS,MAAM,CAACC,KAAKC,SAAS,CAACH,QAAQI,MAAM,CAAC;AACnG,MAAMC,qBAAqB,IAAI,KAAK,KAAK,KAAK;AAC9C,MAAMC,gBAAgB,CAACC,SAA4D,CAAA;QACjFC,gBAAgBD,OAAOC,cAAc;QAAEC,OAAOF,OAAOE,KAAK;QAAEC,cAAcH,OAAOG,YAAY;QAC7FC,cAAcJ,OAAOI,YAAY;QAAEC,WAAWL,OAAOK,SAAS;QAAEC,UAAUN,OAAOM,QAAQ;QACzFC,MAAMP,OAAOO,IAAI;QAAEC,OAAOR,OAAOQ,KAAK;IACxC,CAAA;AACA,MAAMC,YAAY,CAACT,SAA8C,CAAA;QAC/DC,gBAAgBD,OAAOC,cAAc;QAAES,WAAWV,OAAOU,SAAS;QAAEC,UAAUX,OAAOY,IAAI;QACzFC,oBAAoBb,OAAOa,kBAAkB;QAAEP,UAAUN,OAAOM,QAAQ;QAAEE,OAAOR,OAAOQ,KAAK;IAC/F,CAAA;AAYA,OAAO,MAAMM,sCAAsC,CACjDC,SAAqBC,UAAwBC;IAE7C,MAAMC,WAAWD,QAAQC,QAAQ,IAAI;IACrC,MAAMC,WAAW5B,yBAAyBwB,SAAS;QAACK,WAAW;YAC7D;YAAe;YAAc;YAAkB;YAAgB;YAAiB;YAAqB;SACtG;QAAEC,MAAM;YAAC;YAAiB;YAAY;eAAaJ,QAAQK,eAAe,IAAI,EAAE;SAAE;IAAA,GAAGL,QAAQM,KAAK;IACnG,MAAMC,UAAU,CAACC,cAAkCC,QACjDR,UAA4BS,cAAc,KAAK,GAA2B,CAAA;YAC1EC,mBAAmBH,aAAaG,iBAAiB;YAAE3B,gBAAgBwB,aAAab,IAAI;YACpFiB,MAAMJ,aAAaI,IAAI;YAAEC,YAAY/B,cAAc2B;YAASK,oBAAoBN,aAAaM,kBAAkB;YAC/GC,MAAML,cAAcV,QAAQgB,WAAW,CAACR,cAAcP,YAAYgB;YAAW1B,OAAOiB,aAAajB,KAAK;QACxG,CAAA;IACA,MAAM2B,QAAQ,OAAOd;QACnB,MAAMe,UAAU,MAAMf,KAAc,CAAC;;;iDAGQ,CAAC,EAAE;YAAC,GAAGL,QAAQ;QAAA;QAC5D,IAAGoB,YAAY,MAAM;YACnB,MAAM,IAAIjD,UAAU;QACtB;QACA,MAAMkD,MAAMhB,MAAML;IACpB;IACA,MAAMqB,QAAQ,CAAChB,MAAiBiB,MAAqCrB,QAAQsB,iBAAiB,CAAClB,MAAMiB;IACrG,MAAME,YAAY,OAAOnB,MAAiBoB,MAAoBpC;QAC5D,MAAMqC,SAAS,MAAMrB,KAAmB,CAAC;;;;;;;;;;;4DAWe,CAAC,EAAE;YACzDsB,WAAWF,KAAKG,MAAM;YAAEH,MAAM,CAAC,SAAS,EAAEA,KAAKpC,SAAS,EAAE;YAAEwC,UAAU,CAAC,MAAM,EAAEJ,KAAKG,MAAM,EAAE;YAC5FvC;YAAWyC,IAAI,CAAC,SAAS,EAAEzC,WAAW;QACxC;QACA,IAAG,CAACqC,QAAQ;YACV,MAAM,IAAIvD,UAAU;QACtB;QACA,MAAMkD,MAAMhB,MAAMqB;QAClB,OAAOA;IACT;IACA,MAAMjB,eAAe,OAAOJ,MAAiB0B;QAC3C,MAAMC,QAAQ,MAAM3B,KAAyB,yCAAyC;YAAC0B;QAAE;QACzF,IAAG,CAACC,SAASA,MAAMC,iBAAiB,KAAK,KAAKD,MAAMxC,KAAK,KAAK,UAAU;YACtE,MAAM,IAAIrB,UAAU;QACtB;QACA,OAAO6D;IACT;IACA,MAAMtB,SAAS,OAAOL,MAAiBpB,gBAAwBI;QAC7D,MAAM2C,QAAQ,MAAM3B,KAAmB,CAAC;2FAC+C,CAAC,EAAE;YAACpB;YAAgBI;QAAS;QACpH,IAAG,CAAC2C,OAAO;YACT,MAAM,IAAI7D,UAAU;QACtB;QACA,OAAO6D;IACT;IACA,MAAME,SAAS,CAAC7B,MAAiBpB,gBAAwBkD,UAAqC,cAAc,GAC1G9D,2BAA2BgC,MAAML,UAAU;YAACf;YAAgBkD;QAAO;IACrE,MAAMC,gBAAgB,CAACC,OAA6BC;QAClD,IAAGD,MAAMtB,kBAAkB,KAAKuB,YAAYD,MAAMxB,IAAI,KAAK,SAAS;YAClE,MAAM,IAAI1C,UAAU;QACtB;IACF;IACA,MAAMoE,QAAQ,OACZlC,MAAiBpB,gBAAwBC,OAAesD,YAAoBlD;QAE5E,MAAMlB,gBAAgBiC,MAAM;YAACoC,gBAAgBzC,SAASX,SAAS;YAAEJ;YAAgB4B,MAAM;YACrF,GAAI3B,QAAQ;gBAACwD,iBAAiBxD;YAAK,IAAI,CAAC,CAAC;YAAGsD;YAAYlD;QAAQ;IACpE;IACA,MAAMqD,UAAU,OAAUtC,MAAiBuC,QAAgBnE;QACzD,MAAMoE,MAAMrE,KAAK;YAACwB,SAAS4B,MAAM;YAAE5B,SAASX,SAAS;YAAEuD;YAAQnE,MAAMqE,cAAc;SAAC;QACpF,MAAMC,cAAcvE,KAAKC;QACzB,MAAMuE,QAAQ,MAAM3C,KAAyD,yCAAyC;YAACwC;QAAG;QAC1H,IAAGG,SAASA,MAAMD,WAAW,KAAKA,aAAa;YAC7C,MAAM,IAAI5E,UAAU;QACtB;QACA,OAAO;YAAC6E,OAAOA,OAAOC;YAAQC,MAAM,CAACD,SAAc5C,KAAK,8CAA8C;oBACpGrB,QAAQ;wBAACY,MAAMiD;wBAAKM,OAAOC,KAAKC,GAAG;wBAAIC,aAAatD,SAAS4B,MAAM;wBAAEmB;wBACnE1D,WAAWW,SAASX,SAAS;wBAAE4D;oBAAM;gBACzC;QAAE;IACJ;IACA,MAAMM,YAAY,OAAOlD;QACvB,MAAMwC,MAAMrE,KAAK;YAACwB,SAAS4B,MAAM;YAAE4B,KAAKC,KAAK,CAACL,KAAKC,GAAG,KAAK;SAAS;QACpE,MAAMjC,UAAU,MAAMf,KAAc,CAAC;;;mCAGN,CAAC,EAAE;YAACwC;YAAKjB,QAAQ5B,SAAS4B,MAAM;QAAA;QAC/D,IAAGR,YAAY,MAAM;YACnB,MAAM,IAAIjD,UAAU;QACtB;IACF;IACA,MAAMuF,YAAY,OAChBrD,MAAiBpB,gBAAwBqC,KAAmB/B,MAAsBJ;QAElF,MAAM4C,KAAK7D;QACX,MAAMyF,gBAAgB,MAAMtD,KAC1B,4EAA4E;YAACpB;QAAc;QAC7F,MAAMD,SAAS;YAAC4E,OAAO,CAAC,SAAS,EAAEtC,IAAIjC,SAAS,EAAE;YAAEO,MAAMmC;YAAI8B,KAAK,CAAC,cAAc,EAAE5E,gBAAgB;YAClG6E,YAAYV,KAAKC,GAAG;YAAIpE;YAAgB8E,YAAY,GAAG9E,eAAe,CAAC,EAAEqC,IAAIjC,SAAS,EAAE;YAAEH,OAAOhB;YACjG8F,mBAAmB7E,eAAe,IAAI,AAACwE,CAAAA,iBAAiB,CAAA,IAAK,IAAI;YAAGxE;YAAcE,WAAWiC,IAAIjC,SAAS;YAAEC,UAAU;YAAGC;YAAMC,OAAO;YAAmBoC,QAAQN,IAAIM,MAAM;QAAA;QAC7K,MAAMvB,KAAK,mDAAmD;YAACrB;QAAM;QACrE,MAAMqB,KAAK,CAAC;;8CAE8B,CAAC,EAAE;YAC3CpB;YAAgBwC,MAAM,CAAC,MAAM,EAAEH,IAAIM,MAAM,EAAE;YAAEyB,KAAKD,KAAKC,GAAG;YAAIvB,IAAI,CAAC,cAAc,EAAE7C,gBAAgB;YAAE2C,QAAQN,IAAIM,MAAM;QACzH;QACA,OAAO5C;IACT;IACA,MAAMiF,YAAY,OAAO5D,MAAiBpB,gBAAwBqC;QAChE,MAAMS,KAAK7D;QACX,MAAMc,SAAuB;YAACY,MAAMmC;YAAI9C;YAAgBS,WAAW0D,KAAKC,GAAG,KAAKvE;YAC9Ea,UAAUoC;YAAIlC,oBAAoBG,SAASX,SAAS;YAAE6E,kBAAkB5C,IAAIjC,SAAS;YAAE8E,eAAe7C,IAAIM,MAAM;YAAEtC,UAAU;YAAGE,OAAO;QAAS;QACjJ,MAAMa,KAAK,6CAA6C;YAACrB,QAAQ;gBAAC,GAAGA,MAAM;gBACzEoF,WAAWhB,KAAKC,GAAG;gBAAIU,YAAY,GAAG9E,eAAe,CAAC,EAAEqC,IAAIjC,SAAS,EAAE;gBAAEE,MAAM;YAAQ;QAAC;QAC1F,MAAMgD,MAAMlC,MAAMpB,gBAAgB,IAAI8C,IAAI;QAC1C,OAAOtC,UAAUT;IACnB;IACA,MAAMqF,gBAAgB,OAAOhE,MAAiBpB;QAC5C,MAAMoB,KAAK,CAAC;;;gCAGgB,CAAC,EAAE;YAACpB;YAAgBoE,KAAKD,KAAKC,GAAG;QAAE;IACjE;IACA,MAAMiB,oBAAoB,CAAC7F,QAA2D0B,SAAS,OAAOE;YACpG,MAAMc,MAAMd;YACZ,MAAMqB,SAAS,MAAMF,UAAUnB,MAAML,UAAUvB,MAAM8F,oBAAoB;YACzE,MAAMC,OAAOhG,KAAK;gBAAC;mBAAgB;oBAACwB,SAASX,SAAS;oBAAEqC,OAAOrC,SAAS;iBAAC,CAACoF,IAAI;aAAG;YACjF,MAAMC,WAAW,MAAMrE,KAAyB,2EAA2E;gBAACmE;YAAI;YAChI,IAAGE,UAAU;gBACX,MAAMxC,OAAO7B,MAAMqE,SAAS9E,IAAI;gBAChC,OAAOY,QAAQkE,UAAU,MAAMhE,OAAOL,MAAMqE,SAAS9E,IAAI,EAAEI,SAASX,SAAS,GAAGa;YAClF;YACA,MAAMqD,UAAUlD;YAChB,MAAM0B,KAAK,CAAC,OAAO,EAAEyC,MAAM;YAC3B,MAAMxF,SAA6B;gBAACY,MAAMmC;gBAAInB,mBAAmB;gBAAGqB,mBAAmB;gBACrFpB,MAAM;gBAAU8D,cAAc;gBAAG5D,oBAAoB;gBAAGvB,OAAO;YAAQ;YACzE,MAAMa,KAAK,+CAA+C;gBAACrB,QAAQ;oBAAC,GAAGA,MAAM;oBAC3EmE,OAAOC,KAAKC,GAAG;oBAAIuB,oBAAoB5E,SAASX,SAAS;oBAAEwF,eAAeL;oBAAMM,UAAU;gBAAI;YAAC;YACjG,MAAMC,MAAM,MAAMrB,UAAUrD,MAAM0B,IAAI/B,UAAU,UAAU;YAC1D,MAAM0D,UAAUrD,MAAM0B,IAAIL,QAAQ,UAAU;YAC5C,MAAMa,MAAMlC,MAAM0B,IAAIgD,IAAI7F,KAAK,EAAE6C,IAAI;YACrC,OAAOvB,QAAQxB,QAAQ+F,KAAK7E;QAC9B;IACA,MAAM8E,cAAc,CAACvG,QAA0D0B,SAAS,OAAOE;YAC7F,MAAMc,MAAMd;YACZ,MAAM4E,UAAU,MAAMtC,QAA6BtC,MAAM,eAAe5B;YACxE,IAAGwG,QAAQjC,KAAK,EAAE;gBAChB,OAAOiC,QAAQjC,KAAK;YACtB;YACA,MAAMO,UAAUlD;YAChB,MAAM6E,UAA0B,EAAE;YAClC,KAAI,MAAM7F,aAAaZ,MAAM0G,gBAAgB,CAAE;gBAC7CD,QAAQE,IAAI,CAAC,MAAM5D,UAAUnB,MAAML,UAAUX;YAC/C;YACA,MAAM0C,KAAK7D;YACX,MAAMmH,iBAAiB7G,KAAK;gBAAC;gBAAcC,MAAMuC,IAAI;aAAC;YACtD,MAAMhC,SAA6B;gBAACY,MAAMmC;gBAAInB,mBAAmB;gBAAGqB,mBAAmB;gBAAGpB,MAAM;gBAC9F8D,cAAc;gBAAG5D,oBAAoB;gBAAGC,MAAMvC,MAAMuC,IAAI;gBAAEsE,oBAAoBD;gBAC9EE,cAActF,QAAQuF,YAAY,CAAC/G,MAAMuC,IAAI,EAAEqE;gBAAiB7F,OAAO;YAAS;YAClF,MAAMa,KAAK,+CAA+C;gBAACrB,QAAQ;oBAAC,GAAGA,MAAM;oBAC3EmE,OAAOC,KAAKC,GAAG;oBAAIuB,oBAAoB5E,SAASX,SAAS;oBAAEyF,UAAU;gBAAK;YAAC;YAC7E,MAAMC,MAAM,MAAMrB,UAAUrD,MAAM0B,IAAI/B,UAAU,SAAS;YACzD,KAAI,MAAM0B,UAAUwD,QAAS;gBAC3B,MAAMjB,UAAU5D,MAAM0B,IAAIL;YAC5B;YACA,MAAMa,MAAMlC,MAAM0B,IAAIgD,IAAI7F,KAAK,EAAE6C,IAAI;YACrC,MAAMkB,SAASzC,QAAQxB,QAAQ+F,KAAK7E;YACpC,MAAM+E,QAAQ/B,IAAI,CAACD;YACnB,OAAOA;QACT;IACA,MAAMwC,eAAe,CAAChH,QAA0D0B,SAAS,OAAOE;YAC9F,MAAMc,MAAMd;YACZ,MAAM4E,UAAU,MAAMtC,QAA4BtC,MAAM,UAAU5B;YAClE,IAAGwG,QAAQjC,KAAK,EAAE;gBAChB,OAAOiC,QAAQjC,KAAK;YACtB;YACA,MAAM+B,MAAM,MAAM7C,OAAO7B,MAAM5B,MAAMQ,cAAc,EAAE;YACrDmD,cAAc2C,KAAKtG,MAAMiH,gBAAgB;YACzC,MAAMhE,SAAS,MAAMF,UAAUnB,MAAML,UAAUvB,MAAMY,SAAS;YAC9D,MAAMgF,cAAchE,MAAM5B,MAAMQ,cAAc;YAC9C,MAAM+D,QAAQ,MAAM3C,KAAmB,oFACrC;gBAACwC,KAAK,GAAGpE,MAAMQ,cAAc,CAAC,CAAC,EAAER,MAAMY,SAAS,EAAE;YAAA;YACpD,IAAG2D,OAAO;gBACR,MAAMC,SAASxD,UAAUuD;gBACzB,MAAMiC,QAAQ/B,IAAI,CAACD;gBACnB,OAAOA;YACT;YACA,MAAM0C,SAAS,MAAMtF,KAAyD,CAAC;;;;;;KAM9E,CAAC,EAAE;gBAACpB,gBAAgBR,MAAMQ,cAAc;gBAAEoE,KAAKD,KAAKC,GAAG;gBAAIhE,WAAWZ,MAAMY,SAAS;YAAA;YACtF,IAAG,CAACsG,UAAUA,OAAOC,MAAM,IAAID,OAAOE,KAAK,IAAI,IAAI;gBACjD,MAAM,IAAI1H,UAAU;YACtB;YACA,MAAMoF,UAAUlD;YAChB,MAAM4C,SAAS,MAAMgB,UAAU5D,MAAM5B,MAAMQ,cAAc,EAAEyC;YAC3D,MAAMuD,QAAQ/B,IAAI,CAACD;YACnB,OAAOA;QACT;IACA,MAAM6C,gBAAgB,CACpBrH,OAA0BsH,SAE1B5F,SAAS,OAAOE;YACd,MAAMc,MAAMd;YACZ,MAAM4E,UAAU,MAAMtC,QAAkDtC,MAAM0F,SAAS,WAAW,WAAWtH;YAC7G,IAAGwG,QAAQjC,KAAK,EAAE;gBAChB,OAAOiC,QAAQjC,KAAK;YACtB;YACA,MAAMgD,SAAS,MAAM3F,KAAmB,uCAAuC;gBAAC0B,IAAItD,MAAMkB,QAAQ;YAAA;YAClG,IAAG,CAACqG,UAAUA,OAAO9B,gBAAgB,KAAKlE,SAASX,SAAS,IAAI2G,OAAO7B,aAAa,KAAKnE,SAAS4B,MAAM,IACnGoE,OAAOxG,KAAK,KAAK,aAAawG,OAAOtG,SAAS,IAAI0D,KAAKC,GAAG,IAAI;gBACjE,MAAM,IAAIlF,UAAU;YACtB;YACA,IAAG6H,OAAO1G,QAAQ,KAAKb,MAAMiH,gBAAgB,EAAE;gBAC7C,MAAM,IAAIvH,UAAU;YACtB;YACA,MAAM8H,UAAU,MAAMxF,aAAaJ,MAAM2F,OAAO/G,cAAc;YAC9D,IAAGgH,QAAQpF,IAAI,KAAK,SAAS;gBAC3B,MAAM,IAAI1C,UAAU;YACtB;YACA,IAAI8E;YACJ,IAAG8C,QAAQ;gBACT,MAAMG,UAAU,MAAMxF,OAAOL,MAAM4F,QAAQrG,IAAI,EAAEoG,OAAOnG,kBAAkB;gBAC1E,IAAG,CAAC;oBAAC;oBAAS;iBAAQ,CAACsG,QAAQ,CAACD,QAAQ3G,IAAI,KAAK0G,QAAQrF,iBAAiB,IAAI,IAAI;oBAChF,MAAM,IAAIzC,UAAU;gBACtB;gBACA,MAAMkD,MAAMhB,MAAM;oBAAChB,WAAW6G,QAAQ7G,SAAS;oBAAEuC,QAAQsE,QAAQtE,MAAM;gBAAA;gBACvE,MAAMJ,UAAUnB,MAAM;oBAAChB,WAAW6G,QAAQ7G,SAAS;oBAAEuC,QAAQsE,QAAQtE,MAAM;gBAAA,GAAG5B,SAASX,SAAS;gBAChG,MAAM0F,MAAM,MAAMrB,UAAUrD,MAAM4F,QAAQrG,IAAI,EAAEI,UAAU,UAAUiG,QAAQtB,YAAY,GAAG;gBAC3F,MAAMyB,UAAU,MAAM/F,KAAyB,CAAC;;qCAEnB,CAAC,EAAE;oBAACgG,OAAOJ,QAAQrF,iBAAiB,GAAG;oBAAGmB,IAAIkE,QAAQrG,IAAI;oBACrFN,UAAU2G,QAAQlF,kBAAkB,GAAG;oBACvCvB,OAAOyG,QAAQrF,iBAAiB,GAAG,KAAK,IAAI,WAAWqF,QAAQzG,KAAK;gBAAA;gBACtE,IAAG,CAAC4G,SAAS;oBACX,MAAM,IAAIjI,UAAU;gBACtB;gBACA,MAAMoE,MAAMlC,MAAM4F,QAAQrG,IAAI,EAAEmF,IAAI7F,KAAK,EAAE6F,IAAInF,IAAI,EAAEwG,QAAQrF,kBAAkB;gBAC/EkC,SAASzC,QAAQ4F,SAASrB,KAAK7E;YACjC,OAAO;gBACL+C,SAAS;oBAAC,GAAGxD,UAAUuG,OAAO;oBAAE1G,UAAU0G,OAAO1G,QAAQ,GAAG;oBAAGE,OAAO;gBAAU;gBAChF,MAAM+C,MAAMlC,MAAM4F,QAAQrG,IAAI,EAAE,IAAIoG,OAAOpG,IAAI,EAAEoG,OAAO1G,QAAQ,GAAG;YACrE;YACA,MAAMe,KAAK,CAAC;kCACgB,CAAC,EAAE;gBAAC0B,IAAIiE,OAAOpG,IAAI;gBAAEyD,KAAKD,KAAKC,GAAG;gBAAI/D,UAAU0G,OAAO1G,QAAQ,GAAG;gBAC5FE,OAAOuG,SAAS,aAAa;YAAU;YACzC,MAAMd,QAAQ/B,IAAI,CAACD;YACnB,OAAOA;QACT;IACF,MAAMqD,mBAAmB,CACvB1D,QACAnE,QACiC0B,SAAS,OAAOE;YACjD,MAAMc,MAAMd;YACZ,MAAM4E,UAAU,MAAMtC,QAA6BtC,MAAMuC,QAAQnE;YACjE,IAAGwG,QAAQjC,KAAK,EAAE;gBAChB,OAAOiC,QAAQjC,KAAK;YACtB;YACA,MAAMuD,YAAY,MAAMrE,OAAO7B,MAAM5B,MAAMQ,cAAc;YACzDmD,cAAcmE,WAAW9H,MAAMiH,gBAAgB;YAC/C,MAAMO,UAAU,MAAMxF,aAAaJ,MAAM5B,MAAMQ,cAAc;YAC7D,MAAM8F,MAAM,MAAMrE,OAAOL,MAAM4F,QAAQrG,IAAI,EAAEI,SAASX,SAAS;YAC/D,MAAMmH,kBAAkB,eAAe/H,QAAQA,MAAMY,SAAS,GAAGW,SAASX,SAAS;YACnF,MAAMqC,SAAS8E,oBAAoBxG,SAASX,SAAS,GAAG0F,MAAM,MAAMrE,OAAOL,MAAM4F,QAAQrG,IAAI,EAAE4G;YAC/F,MAAMC,UAAU7D,WAAW,WAAWA,WAAW;YACjD,IAAG,AAACA,CAAAA,WAAW,UAAUA,WAAW,UAAS,KAAOmC,CAAAA,IAAIxF,IAAI,KAAK,WAAWmC,OAAO9B,IAAI,KAAKmF,IAAInF,IAAI,AAAD,GAAI;gBACrG,MAAM,IAAIzB,UAAU;YACtB;YACA,IAAGyE,WAAW,YAAalB,CAAAA,OAAO9B,IAAI,KAAKmF,IAAInF,IAAI,IAAI8B,OAAOnC,IAAI,KAAK,WAClE,CAAC;gBAAC;gBAAS;aAAQ,CAAC4G,QAAQ,CAACpB,IAAIxF,IAAI,KAAMwF,IAAIxF,IAAI,KAAK,WAAWmC,OAAOnC,IAAI,KAAK,QAAQ,GAAI;gBAClG,MAAM,IAAIpB,UAAU;YACtB;YACA,IAAGyE,WAAW,WAAWmC,IAAIxF,IAAI,KAAK,WAAW0G,QAAQrF,iBAAiB,GAAG,GAAG;gBAC9E,MAAM,IAAIzC,UAAU;YACtB;YACA,IAAGyE,WAAW,UAAUlB,OAAOnC,IAAI,KAAK,SAAS;gBAC/C,MAAM,IAAIpB,UAAU;YACtB;YACA,IAAGyE,WAAW,cAAeA,WAAW,UAAU,UAAUnE,SAASA,MAAMc,IAAI,KAAK,SAAU;gBAC5F,MAAM8B,MAAMhB,MAAM;oBAAChB,WAAWqC,OAAOrC,SAAS;oBAAEuC,QAAQF,OAAOE,MAAM;gBAAA;YACvE;YACA,IAAI8E,YAAY3B;YAChB,IAAGnC,WAAW,YAAY;gBACxB,MAAMvC,KAAK,yFACT;oBAAC0B,IAAIgD,IAAInF,IAAI;oBAAEN,UAAUyF,IAAIzF,QAAQ,GAAG;gBAAC;gBAC3C,MAAMe,KAAK,yFACT;oBAAC0B,IAAIL,OAAO9B,IAAI;oBAAEN,UAAUoC,OAAOpC,QAAQ,GAAG;gBAAC;gBACjDoH,YAAY;oBAAC,GAAG3B,GAAG;oBAAEzF,UAAUyF,IAAIzF,QAAQ,GAAG;oBAAGC,MAAM;gBAAO;YAChE,OAAO,IAAGqD,WAAW,UAAU,UAAUnE,OAAO;gBAC9C,MAAM4B,KAAK,uFACT;oBAAC0B,IAAIL,OAAO9B,IAAI;oBAAEN,UAAUoC,OAAOpC,QAAQ,GAAG;oBAAGC,MAAMd,MAAMc,IAAI;gBAAA;YACrE,OAAO,IAAGkH,SAAS;gBACjB,MAAMjH,QAAQoD,WAAW,UAAU,SAAS;gBAC5C,MAAMvC,KAAK,CAAC;qGACmF,CAAC,EAAE;oBAChGc,OAAOnB,SAASX,SAAS;oBAAE0C,IAAIL,OAAO9B,IAAI;oBAAEyD,KAAKD,KAAKC,GAAG;oBAAI/D,UAAUoC,OAAOpC,QAAQ,GAAG;oBACzFqH,UAAUV,QAAQtB,YAAY;oBAAEnF;gBAClC;gBACA,IAAGoD,WAAW,SAAS;oBACrB8D,YAAY;wBAAC,GAAG3B,GAAG;wBAAE3F,cAAc6G,QAAQtB,YAAY;wBAAErF,UAAUyF,IAAIzF,QAAQ,GAAG;wBAAGE;oBAAK;gBAC5F;gBACA,MAAMa,KAAK,CAAC;;;2EAGyD,CAAC,EAAE;oBACtEpB,gBAAgBgH,QAAQrG,IAAI;oBAAE6B,MAAM,CAAC,MAAM,EAAEC,OAAOE,MAAM,EAAE;oBAAEE,IAAI,CAAC,cAAc,EAAEmE,QAAQrG,IAAI,EAAE;oBAAEgC,QAAQF,OAAOE,MAAM;gBAC1H;YACF;YACA,IAAG6E,WAAY7D,WAAW,UAAU,UAAUnE,SAASA,MAAMc,IAAI,KAAK,UAAW;gBAC/E,MAAMc,KAAK,CAAC;;;kCAGgB,CAAC,EAAE;oBAACuG,OAAOH,WAAWR,QAAQrF,iBAAiB,KAAK;oBAC9E3B,gBAAgBgH,QAAQrG,IAAI;oBAAEyD,KAAKD,KAAKC,GAAG;oBAAIhE,WAAWqC,OAAOrC,SAAS;gBAAA;YAC9E;YACA,MAAMgH,QAAQJ,QAAQrF,iBAAiB,GAAI6F,CAAAA,UAAU,IAAI,CAAA;YACzD,MAAML,UAAU,MAAM/F,KAAyB,CAAC;;iCAEnB,CAAC,EAAE;gBAACgG;gBAAOtE,IAAIkE,QAAQrG,IAAI;gBAAEN,UAAU2G,QAAQlF,kBAAkB,GAAG;gBAC/FvB,OAAO6G,UAAU,IAAI,WAAWJ,QAAQzG,KAAK;YAAA;YAC/C,IAAG,CAAC4G,SAAS;gBACX,MAAM,IAAIjI,UAAU;YACtB;YACA,MAAMoE,MAAMlC,MAAM4F,QAAQrG,IAAI,EAAE8B,OAAOxC,KAAK,EAAEwC,OAAO9B,IAAI,EAAEwG,QAAQrF,kBAAkB;YACrF,MAAMkC,SAASzC,QAAQ4F,SAASM,WAAWxG;YAC3C,MAAM+E,QAAQ/B,IAAI,CAACD;YACnB,OAAOA;QACT;IACA,MAAM4D,oBAAoB,CAACpI,QACzB0B,SAAS,OAAOE;YACd,MAAMc,MAAMd;YACZ,MAAMyG,MAAM,MAAMzG,KAAe,CAAC;;gHAEwE,CAAC,EAAE;gBAC3G,GAAGL,QAAQ;gBAAE+G,OAAOtI,MAAMsI,KAAK,IAAI;gBAAIC,OAAOvI,MAAMuI,KAAK,IAAI;YAC/D;YACA,MAAMC,UAAiC,EAAE;YACzC,KAAI,MAAMlF,MAAM+E,OAAO,EAAE,CAAE;gBACzB,IAAI;oBACF,MAAM5E,OAAO7B,MAAM0B;oBACnB,MAAMkE,UAAU,MAAMxF,aAAaJ,MAAM0B;oBACzC,IAAGkE,QAAQpF,IAAI,KAAK,UAAU;wBAC5B,MAAMqG,OAAO,MAAM7G,KAAmB,CAAC;iGAC8C,CAAC,EAAE;4BAAC0B;4BAAI1C,WAAWW,SAASX,SAAS;wBAAA;wBAC1H,IAAG,CAAC6H,MAAM;4BACR;wBACF;wBACA,MAAM1F,UAAUnB,MAAML,UAAUkH,KAAK7H,SAAS;oBAChD;oBACA4H,QAAQ7B,IAAI,CAAC5E,QAAQyF,SAAS,MAAMvF,OAAOL,MAAM0B,IAAI/B,SAASX,SAAS,GAAGa,UAAU;gBACtF,EAAE,OAAMiH,OAAO;oBACb,IAAG,CAAEA,CAAAA,iBAAiBhJ,SAAQ,KAAMgJ,MAAMC,IAAI,KAAK,aAAa;wBAC9D,MAAMD;oBACR;gBACF;YACF;YACA,OAAOF;QACT;IACF,MAAMI,cAAc,CAAC5I,QAAiE0B,SAAS,OAAOE;YACpG,MAAMc,MAAMd;YACZ,MAAMiH,UAAU,MAAMjH,KAAqB,CAAC;;;;;;;;;;;;;;;;;;;kDAmBE,CAAC,EAAE;gBAAC,GAAGL,QAAQ;gBAAE+G,OAAOtI,MAAMsI,KAAK,IAAI;gBAAIC,OAAOvI,MAAMuI,KAAK,IAAI;gBAAI3D,KAAKD,KAAKC,GAAG;YAAE;YAClI,OAAO,AAACiE,CAAAA,WAAW,EAAE,AAAD,EAAGC,GAAG,CAAC9H;QAC7B;IACA,MAAM+H,kBAAkB,CAAC/I,QACvB0B,SAAS,OAAOE;YACd,MAAMc,MAAMd;YACZ,MAAM6B,OAAO7B,MAAM5B,MAAMQ,cAAc;YACvC,MAAMqI,UAAU,MAAMjH,KAAqB,CAAC;;;;;;;;;;qDAUG,CAAC,EAAE;gBAChDpB,gBAAgBR,MAAMQ,cAAc;gBAAEwI,eAAe,CAAC,SAAS,EAAEzH,SAASX,SAAS,EAAE;gBAAEqI,YAAY,CAAC,MAAM,EAAE1H,SAAS4B,MAAM,EAAE;YAC/H;YACA,OAAO,AAAC0F,CAAAA,WAAW,EAAE,AAAD,EAAGC,GAAG,CAACxI;QAC7B;IACF,OAAO;QACL4I,cAAc,CAAClJ,QAA6BqH,cAAcrH,OAAO;QACjEmJ,kBAAkB,CAACnJ,QAAiC6H,iBAAiB,QAAQ7H;QAC7EuG;QACA6C,eAAe,CAACpJ,QAA6BqH,cAAcrH,OAAO;QAClE6F;QAAmBkD;QAAiB/B;QACpCqC,mBAAmB,CAACrJ,QAAkC6H,iBAAiB,SAAS7H;QAChFoI;QAAmBQ;QACnBU,cAAc,CAACtJ,QAA6B6H,iBAAiB,UAAU7H;QACvEuJ,mBAAmB,CAACvJ,QAAkC6H,iBAAiB,YAAY7H;IACrF;AACF,EAAE;AAGF,MAAMwJ,QAAQ,CAACC;IACb,IAAG,CAACA,WAAW;QACb,MAAM,IAAI/J,UAAU;IACtB;AACF;AACA,MAAMgK,WAAW,CAAC1J;IAChBwJ,MAAMG,QAAQ3J,UAAUH,iBAAiBG,MAAMqE,cAAc,KACxDuF,OAAOC,aAAa,CAAC7J,MAAMiH,gBAAgB,KAAKjH,MAAMiH,gBAAgB,GAAG;AAChF;AACA,MAAM6C,uBAAuB,CAAC9J;IAC5B0J,SAAS1J;IACTwJ,MAAM3J,iBAAiBG,MAAMQ,cAAc;AAC7C;AACA,MAAMuJ,mBAAmB,CAAC/J;IACxB8J,qBAAqB9J;IACrBwJ,MAAM3J,iBAAiBG,MAAMY,SAAS;AACxC;AACA,MAAMoJ,OAAO,CAAChK,QAA+BwJ,MAAMG,QAAQ3J,UACrDA,CAAAA,MAAMuI,KAAK,KAAK9F,aAAcmH,OAAOC,aAAa,CAAC7J,MAAMuI,KAAK,KAAKvI,MAAMuI,KAAK,GAAG,KAAKvI,MAAMuI,KAAK,IAAI,EAAE,KACvGvI,CAAAA,MAAMsI,KAAK,KAAK7F,aAAa5C,iBAAiBG,MAAMsI,KAAK,CAAA;AAE/D,OAAO,MAAM2B,mCAAmC,CAC9C1I,UAAwB2I;IAExB,IAAG,CAAC3I,YAAY,CAAC1B,iBAAiB0B,SAASX,SAAS,KAAK,CAACf,iBAAiB0B,SAAS4B,MAAM,GAAG;QAC3F,MAAM,IAAIzD,UAAU;IACtB;IACA,OAAO;QACLwJ,cAAc,OAAOlJ;YACnB0J,SAAS1J;YACTwJ,MAAM3J,iBAAiBG,MAAMkB,QAAQ;YACrC,OAAOgJ,WAAWhB,YAAY,CAAClJ;QACjC;QACAmJ,kBAAkB,OAAOnJ;YACvB+J,iBAAiB/J;YACjBwJ,MAAM;gBAAC;gBAAS;aAAS,CAAC9B,QAAQ,CAAC1H,MAAMc,IAAI;YAC7C,OAAOoJ,WAAWf,gBAAgB,CAACnJ;QACrC;QACAuG,aAAa,OAAOvG;YAClBwJ,MAAMG,QAAQ3J,UAAUH,iBAAiBG,MAAMqE,cAAc,KAAK,OAAOrE,MAAMuC,IAAI,KAAK,YACnFvC,MAAMuC,IAAI,CAAC4H,IAAI,GAAGC,MAAM,GAAG,KAAKpK,MAAMuC,IAAI,CAAC6H,MAAM,IAAI,OACrDC,MAAMC,OAAO,CAACtK,MAAM0G,gBAAgB,KACpC1G,MAAM0G,gBAAgB,CAAC0D,MAAM,IAAI,KAAKpK,MAAM0G,gBAAgB,CAAC0D,MAAM,IAAI,MACvEpK,MAAM0G,gBAAgB,CAAC6D,KAAK,CAAC,CAACjH,KAAOzD,iBAAiByD,OAAOA,OAAO/B,SAASX,SAAS,KACtF,IAAI4J,IAAIxK,MAAM0G,gBAAgB,EAAE+D,IAAI,KAAKzK,MAAM0G,gBAAgB,CAAC0D,MAAM;YAC3E,OAAOF,WAAW3D,WAAW,CAACvG;QAChC;QACAoJ,eAAe,OAAOpJ;YACpB0J,SAAS1J;YACTwJ,MAAM3J,iBAAiBG,MAAMkB,QAAQ;YACrC,OAAOgJ,WAAWd,aAAa,CAACpJ;QAClC;QACA6F,mBAAmB,OAAO7F;YACxBwJ,MAAMG,QAAQ3J,UAAUH,iBAAiBG,MAAM8F,oBAAoB,KAC9D9F,MAAM8F,oBAAoB,KAAKvE,SAASX,SAAS;YACtD,OAAOsJ,WAAWrE,iBAAiB,CAAC7F;QACtC;QACA+I,iBAAiB,OAAO/I;YACtBwJ,MAAMG,QAAQ3J,UAAUH,iBAAiBG,MAAMQ,cAAc;YAC7D,OAAO0J,WAAWnB,eAAe,CAAC/I;QACpC;QACAgH,cAAc,OAAOhH;YACnB+J,iBAAiB/J;YACjBwJ,MAAMxJ,MAAMY,SAAS,KAAKW,SAASX,SAAS;YAC5C,OAAOsJ,WAAWlD,YAAY,CAAChH;QACjC;QACAqJ,mBAAmB,OAAOrJ;YACxB8J,qBAAqB9J;YACrB,OAAOkK,WAAWb,iBAAiB,CAACrJ;QACtC;QACAoI,mBAAmB,OAAOpI,QAAuB,CAAC,CAAC;YACjDgK,KAAKhK;YACL,OAAOkK,WAAW9B,iBAAiB,CAACpI;QACtC;QACA4I,aAAa,OAAO5I,QAAuB,CAAC,CAAC;YAC3CgK,KAAKhK;YACL,OAAOkK,WAAWtB,WAAW,CAAC5I;QAChC;QACAsJ,cAAc,OAAOtJ;YACnB+J,iBAAiB/J;YACjBwJ,MAAMxJ,MAAMY,SAAS,KAAKW,SAASX,SAAS;YAC5C,OAAOsJ,WAAWZ,YAAY,CAACtJ;QACjC;QACAuJ,mBAAmB,OAAOvJ;YACxB+J,iBAAiB/J;YACjBwJ,MAAMxJ,MAAMY,SAAS,KAAKW,SAASX,SAAS;YAC5C,OAAOsJ,WAAWX,iBAAiB,CAACvJ;QACtC;IACF;AACF,EAAE"}