@agentshouse/mdruntime 0.1.0-cb2e390ee7b89 → 0.1.0-cb61c07f2d10b

package/dist/chat/provider.js

@@ -1,635 +0,0 @@
-import { createContext, createElement, useCallback, useContext, useEffect, useMemo, useReducer, useRef, useState, useSyncExternalStore, } from 'react';
-import { AssistantRuntimeProvider, createMessageQueue, generateId, useExternalStoreRuntime, } from '@assistant-ui/react';
-import { attempts } from '../attempt.js';
-import { newChat, } from '../conversation.js';
-import { expectedList } from '../expectation.js';
-import { chatDraftRevision } from '../identity.js';
-import { useObserve } from '../react.js';
-import { accepted, answeredOf, outcomeOf, sender, unanswered, } from './acts.js';
-import { CHAT_WINDOW, useEarlier } from './earlier.js';
-import { askedBefore, chatMessages, contextOf } from './messages.js';
-import { conversationChanged, conversationGone, conversationListed, optionChosen, overlay, questionAnswered, sentMessage, } from './overlay.js';
-import { commandIn, commandsOf, optionsOf } from './process.js';
-import { loneOf, questionsOf } from './questions.js';
-import { record, text } from './read.js';
-const SHARED = new WeakMap();
-const LATEST = { limit: CHAT_WINDOW };
-function sharedOf(client) {
-    const held = SHARED.get(client);
-    if (held !== undefined)
-        return held;
-    const fresh = { overlay: overlay(), created: new Map(), sends: 0 };
-    SHARED.set(client, fresh);
-    return fresh;
-}
-function ready(observed) {
-    return observed.state === 'ready' ? observed.value : null;
-}
-function turnOf(result) {
-    return accepted(result) ? text(record(result.result), 'turn') : null;
-}
-async function deliver(client, send, conversation, said, key, idle) {
-    const result = await send.numbered('conversation.send', { conversation, key }, (operation) => client.conversation.send(conversation, operation, said));
-    if (accepted(result))
-        send.expect(sentMessage(key, [conversation], said, turnOf(result)));
-    else if (!unanswered(result))
-        idle();
-    return result;
-}
-const IDLE = { busy: false, outcome: null };
-const SENDING = { state: 'sending' };
-function useActs(overlay, online) {
-    const [running, setRunning] = useState(IDLE);
-    const [tried] = useState(() => attempts());
-    const latest = useRef(0);
-    const mounted = useRef(true);
-    useEffect(() => {
-        mounted.current = true;
-        return () => {
-            mounted.current = false;
-        };
-    }, []);
-    const clear = useCallback(() => {
-        latest.current += 1;
-        setRunning(IDLE);
-    }, []);
-    const call = useCallback((steps, expected = null, then) => {
-        latest.current += 1;
-        const mine = latest.current;
-        const act = overlay.begin();
-        const drawn = typeof expected === 'function' ? null : expected;
-        overlay.expect(act, drawn);
-        setRunning({ busy: true, outcome: expectedList(drawn).length > 0 ? null : SENDING });
-        const attempt = tried.begin(act);
-        const send = sender({
-            online,
-            identity: attempt.identity,
-            expect: (expecting) => overlay.expect(overlay.begin(), expecting),
-            draw: (expecting) => overlay.expect(act, expecting),
-        });
-        return steps(send)
-            .catch(() => ({
-            kind: 'transport-uncertainty',
-            code: 'transport-uncertainty',
-            fields: {},
-            retryable: true,
-        }))
-            .then((result) => {
-            if (accepted(result) && typeof expected === 'function') {
-                overlay.expect(act, expected(result.result));
-            }
-            attempt.settle(answeredOf(result), (one) => overlay.drop(one));
-            if (!mounted.current || latest.current !== mine)
-                return accepted(result);
-            if (accepted(result))
-                then?.(result.result);
-            if (latest.current === mine)
-                setRunning({ busy: false, outcome: outcomeOf(result) });
-            return accepted(result);
-        });
-    }, [overlay, online, tried]);
-    return { ...running, call, clear };
-}
-const ATTACHMENTS = {
-    accept: '*',
-    add: ({ file }) => Promise.resolve({
-        id: generateId(),
-        type: 'file',
-        name: file.name,
-        contentType: file.type,
-        file,
-        status: { type: 'requires-action', reason: 'composer-send' },
-    }),
-    send: (attachment) => Promise.resolve({ ...attachment, status: { type: 'complete' }, content: [] }),
-    remove: () => Promise.resolve(),
-};
-function filesOf(attachments) {
-    return attachments.flatMap((one) => one.file === undefined ? [] : [{ name: one.name, blob: one.file }]);
-}
-function fileOf(file) {
-    return file.blob instanceof File && file.blob.name === file.name
-        ? file.blob
-        : new File([file.blob], file.name, { type: file.blob.type });
-}
-function textOf(parts) {
-    return parts.map((part) => (part.type === 'text' ? (part.text ?? '') : '')).join('');
-}
-function draftOf(message) {
-    return { text: textOf(message.content), files: filesOf(message.attachments ?? []) };
-}
-function appended(draft) {
-    return {
-        role: 'user',
-        content: [{ type: 'text', text: draft.text }],
-        attachments: draft.files.map((file) => ({
-            id: generateId(),
-            type: 'file',
-            name: file.name,
-            contentType: file.blob.type,
-            file: fileOf(file),
-            status: { type: 'complete' },
-            content: [],
-        })),
-        metadata: { custom: {} },
-        createdAt: new Date(),
-        parentId: null,
-        sourceId: null,
-        runConfig: undefined,
-    };
-}
-function composed(state) {
-    return JSON.stringify([state.text, state.attachments.map((one) => one.id)]);
-}
-const ChatContext = createContext(null);
-const ScopeContext = createContext(null);
-export function useChatScope() {
-    const scope = useContext(ScopeContext);
-    if (scope === null)
-        throw new Error('useChat is called outside a ChatProvider');
-    return scope;
-}
-export function useChat() {
-    const chat = useContext(ChatContext);
-    if (chat === null)
-        throw new Error('useChat is called outside a ChatProvider');
-    return chat;
-}
-export function ChatProvider({ client, conversation = null, agent = null, onOpen, children, }) {
-    const shared = sharedOf(client);
-    const asked = JSON.stringify([conversation, agent]);
-    const [followed, setFollowed] = useState(asked);
-    const [open, setOpen] = useState({ conversation, agent });
-    if (followed !== asked) {
-        setFollowed(asked);
-        setOpen({ conversation, agent });
-    }
-    const opened = useRef(open);
-    opened.current = open;
-    const told = useRef(onOpen);
-    told.current = onOpen;
-    const go = useCallback((next) => {
-        opened.current = next;
-        setOpen(next);
-        told.current?.(next);
-    }, []);
-    const listedHeld = ready(useObserve(client, 'conversations'));
-    const agentsHeld = ready(useObserve(client, 'agents'));
-    const sync = ready(useObserve(client, 'sync-status'));
-    const refusal = ready(useObserve(client, 'connection-refusal'));
-    const online = sync !== null && !sync.providerUnreachable && refusal === null;
-    const thread = open.conversation ??
-        (open.agent === null ? null : (shared.created.get(open.agent) ?? newChat(open.agent)));
-    const observed = ready(useObserve(thread === null ? null : client, 'conversation', thread ?? '', LATEST));
-    const held = observed !== null && observed.conversation === thread ? observed : null;
-    const paged = useEarlier(client, thread, held);
-    const version = useSyncExternalStore(shared.overlay.subscribe, shared.overlay.version);
-    useEffect(() => {
-        if (listedHeld !== null)
-            shared.overlay.heardList(listedHeld);
-    }, [shared, listedHeld, version]);
-    useEffect(() => {
-        if (held !== null)
-            shared.overlay.heard(held);
-    }, [shared, held, version]);
-    const conversations = useMemo(() => shared.overlay.conversations(listedHeld ?? []), [shared, listedHeld, version]);
-    const view = useMemo(() => (paged.view === null ? null : shared.overlay.conversation(paged.view)), [shared, paged.view, version]);
-    const agents = agentsHeld ?? [];
-    const known = useRef(agents);
-    known.current = agents;
-    const entry = conversations.find((one) => one.conversation === open.conversation);
-    const running = entry?.state === 'working' || view?.turn != null;
-    const questions = useMemo(() => questionsOf(view), [view]);
-    const lone = loneOf(questions);
-    const commands = useMemo(() => commandsOf(view), [view]);
-    const messages = useMemo(() => chatMessages(view), [view]);
-    const sending = useActs(shared.overlay, online);
-    const behind = useActs(shared.overlay, online);
-    const acting = useActs(shared.overlay, online);
-    const [again, setAgain] = useState(null);
-    const current = useRef(thread);
-    current.current = thread;
-    const seeding = useRef(false);
-    const mounted = useRef(true);
-    useEffect(() => {
-        mounted.current = true;
-        return () => {
-            mounted.current = false;
-        };
-    }, []);
-    const was = useRef(null);
-    const heard = useRef('');
-    const shown = useRef('');
-    const own = useRef([]);
-    const noted = useCallback((to, revision) => {
-        own.current = [...own.current, `${to}\u0000${revision ?? ''}`];
-    }, []);
-    const keep = useCallback((to, draft) => {
-        const revision = draft.text === '' && draft.files.length === 0 ? null : chatDraftRevision();
-        noted(to, revision);
-        void (revision === null
-            ? client.chatDraft.discard(to)
-            : client.chatDraft.write(to, draft, revision));
-    }, [client, noted]);
-    useEffect(() => {
-        heard.current = '';
-        shown.current = '';
-        own.current = own.current.filter((one) => one.startsWith(`${thread}\u0000`));
-        const created = was.current === open;
-        was.current = open;
-        if (created)
-            return;
-        sending.clear();
-        acting.clear();
-        setAgain(null);
-    }, [thread, sending.clear, acting.clear]);
-    const sendTo = (to, said, key, idle, acts = sending) => acts.call((send) => deliver(client, send, to, said, key, idle), sentMessage(key, [to], said, null));
-    const first = (to, said, key, returning, idle) => {
-        const drafted = [newChat(to)];
-        return sending.call(async (send) => {
-            let conversation = shared.created.get(to);
-            if (conversation === undefined) {
-                const answer = await send.carried('conversation.create', { agent: to }, (operation) => client.conversation.create({ agent_id: to, operation_id: operation }));
-                if (!accepted(answer)) {
-                    if (!unanswered(answer)) {
-                        returning();
-                        idle();
-                    }
-                    return answer;
-                }
-                const named = text(record(answer.result), 'conversation');
-                if (named === null)
-                    return answer;
-                conversation = named;
-                shared.created.set(to, conversation);
-                const name = known.current.find((one) => one.identity === to)?.name ?? null;
-                send.expect(conversationListed({
-                    conversation,
-                    agent: { identity: to, name },
-                    name: name ?? '',
-                    created: new Date().toISOString(),
-                    finished: null,
-                    outcome: null,
-                    state: 'idle',
-                    started: null,
-                }));
-            }
-            send.draw(sentMessage(key, [...drafted, conversation], said, null));
-            const result = await deliver(client, send, conversation, said, key, idle);
-            if (!accepted(result))
-                return result;
-            shared.created.delete(to);
-            const now = opened.current;
-            if (mounted.current && now.conversation === null && now.agent === to) {
-                go({ conversation, agent: to });
-            }
-            return result;
-        }, sentMessage(key, drafted, said, null));
-    };
-    const returned = async (to, one) => {
-        const now = (await client.conversation.read(to)).chatDraft;
-        await client.chatDraft.write(to, {
-            text: now === null || now.text === '' ? one.text : `${one.text}\n${now.text}`,
-            files: [...one.files, ...(now?.files ?? [])],
-        });
-    };
-    const sent = () => {
-        shared.sends += 1;
-        return `sent ${shared.sends}`;
-    };
-    const deliverDraft = (said, returning, idle) => {
-        const key = sent();
-        const { conversation: to, agent: by } = opened.current;
-        const attempt = to !== null
-            ? () => void sendTo(to, said, key, idle)
-            : by !== null
-                ? () => void first(by, said, key, returning, idle)
-                : null;
-        if (attempt === null)
-            return;
-        setAgain(() => attempt);
-        attempt();
-    };
-    const control = (name, input, expected) => acting.call((send) => send.carried(name, input, (operation) => client.call(name, { ...input, operation_id: operation })), expected);
-    const carried = (name, act) => {
-        const to = opened.current.conversation;
-        if (to === null)
-            return Promise.resolve(false);
-        return acting.call((send) => send.carried(name, { conversation: to }, () => act(to)));
-    };
-    const stop = () => carried('conversation.interrupt', (to) => client.conversation.interrupt(to));
-    const kill = () => carried('conversation.kill', (to) => client.conversation.kill(to));
-    const answer = (question, response) => {
-        const to = opened.current.conversation;
-        if (to === null || question.secret)
-            return Promise.resolve(false);
-        return acting.call((send) => send.carried('conversation.answer', { conversation: to, question: question.interaction }, () => client.conversation.answer(to, { interaction_id: question.interaction, response })), () => questionAnswered(to, question.interaction));
-    };
-    const choose = (option, value) => {
-        const to = opened.current.conversation;
-        if (to === null)
-            return Promise.resolve(false);
-        return control('conversation.setOption', { conversation_id: to, option, value }, optionChosen(to, option, value));
-    };
-    const done = (to = opened.current.conversation) => to === null
-        ? Promise.resolve(false)
-        : control('conversation.markDone', { conversation_id: to }, conversationChanged(to, { finished: new Date().toISOString() }, (one) => one.finished !== null));
-    const rename = (name, to = opened.current.conversation) => to === null
-        ? Promise.resolve(false)
-        : control('conversation.rename', { conversation_id: to, name }, conversationChanged(to, { name }, (one) => one.name === name));
-    const remove = (to = opened.current.conversation) => to === null
-        ? Promise.resolve(false)
-        : acting.call((send) => send.carried('conversation.delete', { conversation: to }, () => client.conversation.delete(to)), conversationGone(to), () => {
-            const now = opened.current;
-            if (now.conversation === to)
-                go({ conversation: null, agent: now.agent });
-        });
-    const openConversation = (id) => go({
-        conversation: id,
-        agent: conversations.find((one) => one.conversation === id)?.agent.identity ?? null,
-    });
-    const start = (by) => go({ conversation: null, agent: by });
-    const dispatch = useRef(() => undefined);
-    const queues = useRef(new Map());
-    const into = thread ?? '';
-    const laneOf = (key) => {
-        const held = queues.current.get(key);
-        if (held !== undefined)
-            return held;
-        const fresh = {
-            queue: createMessageQueue({ run: (message) => dispatch.current(message, key) }),
-            running: false,
-        };
-        queues.current.set(key, fresh);
-        return fresh;
-    };
-    const lane = laneOf(into);
-    const queue = lane.queue;
-    const [, moved] = useReducer((count) => count + 1, 0);
-    useEffect(() => queue.subscribe(moved), [queue]);
-    useEffect(() => {
-        for (const [key, one] of queues.current) {
-            const now = key === into
-                ? running
-                : conversations.some((entry) => entry.conversation === key && entry.state !== 'idle');
-            const empty = one.queue.adapter.items.length + one.queue.adapter.steerItems.length === 0;
-            if (key !== into && !now && empty) {
-                queues.current.delete(key);
-                continue;
-            }
-            if (now === one.running)
-                continue;
-            one.running = now;
-            if (now)
-                one.queue.notifyBusy();
-            else
-                one.queue.notifyIdle();
-        }
-    }, [into, running, conversations]);
-    const waiting = useRef(new Map());
-    const lanes = () => [...queue.adapter.steerItems, ...queue.adapter.items];
-    const threads = useMemo(() => {
-        const item = (one) => ({
-            id: one.conversation,
-            title: one.name,
-            custom: { agent: one.agent.identity, state: one.state, finished: one.finished },
-        });
-        return {
-            regular: conversations
-                .filter((one) => one.finished === null)
-                .map((one) => ({ ...item(one), status: 'regular' })),
-            archived: conversations
-                .filter((one) => one.finished !== null)
-                .map((one) => ({ ...item(one), status: 'archived' })),
-        };
-    }, [conversations]);
-    const aui = useExternalStoreRuntime({
-        messages,
-        isRunning: running,
-        hasEarlier: paged.hasEarlier,
-        onLoadEarlier: paged.loadEarlier,
-        convertMessage: (message) => message,
-        queue: lined(),
-        onNew: async (message) => lined().enqueue(message),
-        onCancel: async () => {
-            void stop();
-        },
-        onReload: thread === null
-            ? undefined
-            : async (parent) => {
-                const said = askedBefore(view, parent);
-                if (said === null)
-                    return;
-                const draft = { text: said, files: [] };
-                const into = thread;
-                deliverDraft(draft, () => back(draft, into), () => undefined);
-            },
-        adapters: {
-            attachments: ATTACHMENTS,
-            threadList: {
-                ...(thread === null ? {} : { threadId: thread }),
-                threads: threads.regular,
-                archivedThreads: threads.archived,
-                onSwitchToThread: (id) => openConversation(id),
-                onSwitchToNewThread: () => {
-                    const by = open.agent ?? known.current[0]?.identity;
-                    if (by !== undefined)
-                        start(by);
-                },
-                onRename: (id, name) => {
-                    void rename(name, id);
-                },
-                onArchive: (id) => {
-                    void done(id);
-                },
-                onDelete: (id) => {
-                    void remove(id);
-                },
-            },
-        },
-    });
-    function back(one, into) {
-        if (current.current !== into) {
-            void returned(into, one);
-            return;
-        }
-        const composer = aui.thread.composer;
-        const now = composer.getState().text;
-        composer.setText(now === '' ? one.text : `${one.text}\n${now}`);
-        for (const file of one.files)
-            void composer.addAttachment(fileOf(file));
-    }
-    function taken(message) {
-        const said = textOf(message.content);
-        if (lone === null || commandIn(said, commands))
-            return false;
-        void answer(lone.question, lone.question.accept({ [lone.field.name]: said }));
-        return true;
-    }
-    function lined() {
-        const holding = (put) => (message) => {
-            if (taken(message))
-                return;
-            if (!online) {
-                const draft = draftOf(message);
-                const at = current.current;
-                deliverDraft(draft, () => {
-                    if (at !== null)
-                        back(draft, at);
-                }, () => undefined);
-                return;
-            }
-            const known = new Set(lanes().map((one) => one.id));
-            if (!lane.running)
-                queue.notifyIdle();
-            put(message);
-            const added = lanes().find((one) => !known.has(one.id));
-            if (added !== undefined)
-                waiting.current.set(added.id, message);
-        };
-        return {
-            get items() {
-                return queue.adapter.items;
-            },
-            get steerItems() {
-                return queue.adapter.steerItems;
-            },
-            enqueue: holding(queue.adapter.enqueue),
-            steer: holding(queue.adapter.steer),
-            move: queue.adapter.move,
-            edit: queue.adapter.edit,
-            remove: queue.adapter.remove,
-            __internal_setDispatchTransform: queue.adapter.__internal_setDispatchTransform,
-        };
-    }
-    dispatch.current = (message, key) => {
-        const draft = draftOf(message);
-        const idle = () => queues.current.get(key)?.queue.notifyIdle();
-        if (key !== (current.current ?? '')) {
-            void sendTo(key, draft, sent(), idle, behind);
-            return;
-        }
-        const into = current.current;
-        deliverDraft(draft, () => {
-            if (into !== null)
-                back(draft, into);
-        }, idle);
-    };
-    const unqueue = (id) => {
-        const message = waiting.current.get(id);
-        waiting.current.delete(id);
-        queue.adapter.remove(id);
-        return message;
-    };
-    const edit = (id) => {
-        const item = lanes().find((one) => one.id === id);
-        const message = unqueue(id);
-        if (thread === null || item === undefined)
-            return;
-        back(message === undefined ? { text: textOf(item.parts), files: [] } : draftOf(message), thread);
-    };
-    const reconcile = useRef(() => undefined);
-    reconcile.current = () => {
-        if (thread === null || view === null || seeding.current)
-            return;
-        const at = `${thread}\u0000`;
-        const now = `${at}${view.chatDraft?.revision ?? ''}`;
-        if (now === heard.current)
-            return;
-        const echo = own.current.indexOf(now);
-        const known = heard.current.startsWith(at);
-        heard.current = now;
-        if (known && echo >= 0) {
-            own.current = own.current.slice(echo);
-            return;
-        }
-        own.current = own.current.filter((one) => !one.startsWith(at));
-        const composer = aui.thread.composer;
-        const state = composer.getState();
-        const stored = view.chatDraft;
-        const typed = { text: state.text, files: filesOf(state.attachments) };
-        const kept = !known && (typed.text !== '' || typed.files.length > 0);
-        if (kept && stored === null) {
-            shown.current = `${at}${composed(state)}`;
-            keep(thread, typed);
-            return;
-        }
-        const draft = kept
-            ? {
-                text: [stored?.text ?? '', typed.text].filter((one) => one !== '').join('\n'),
-                files: [...(stored?.files ?? []), ...typed.files],
-            }
-            : stored;
-        if (state.text === (draft?.text ?? '') &&
-            state.attachments.length === 0 &&
-            (draft?.files.length ?? 0) === 0) {
-            shown.current = `${at}${composed(state)}`;
-            return;
-        }
-        seeding.current = true;
-        composer.setText(draft?.text ?? '');
-        void composer
-            .clearAttachments()
-            .then(() => Promise.all((draft?.files ?? []).map((file) => composer.addAttachment(fileOf(file)))))
-            .finally(() => {
-            seeding.current = false;
-            if (current.current !== thread) {
-                reconcile.current();
-                return;
-            }
-            const seeded = composer.getState();
-            shown.current = `${at}${composed(seeded)}`;
-            if (kept)
-                keep(thread, { text: seeded.text, files: filesOf(seeded.attachments) });
-            reconcile.current();
-        });
-    };
-    useEffect(() => reconcile.current(), [aui, thread, view]);
-    useEffect(() => {
-        if (thread === null)
-            return;
-        const at = `${thread}\u0000`;
-        const composer = aui.thread.composer;
-        return composer.subscribe(() => {
-            if (seeding.current || !heard.current.startsWith(at))
-                return;
-            const state = composer.getState();
-            const next = `${at}${composed(state)}`;
-            if (next === shown.current)
-                return;
-            shown.current = next;
-            keep(thread, { text: state.text, files: filesOf(state.attachments) });
-        });
-    }, [aui, thread, keep]);
-    const queued = lanes().map((item) => ({ id: item.id, text: textOf(item.parts) }));
-    const chat = {
-        ...open,
-        conversations,
-        agents,
-        view,
-        running,
-        questions,
-        lone,
-        options: optionsOf(view),
-        commands,
-        context: contextOf(view),
-        queued,
-        sending: { busy: sending.busy, outcome: sending.outcome, again },
-        acting: { busy: acting.busy, outcome: acting.outcome },
-        open: openConversation,
-        start,
-        send: (draft) => lined().enqueue(appended(draft)),
-        answer,
-        choose,
-        stop,
-        kill,
-        done: () => done(),
-        rename: (name) => rename(name),
-        remove: () => remove(),
-        edit,
-        unqueue: (id) => {
-            unqueue(id);
-        },
-    };
-    const scope = useMemo(() => ({ client, known: agentsHeld !== null }), [client, agentsHeld]);
-    return createElement(AssistantRuntimeProvider, { runtime: aui }, createElement(ScopeContext.Provider, { value: scope }, createElement(ChatContext.Provider, { value: chat }, children)));
-}

package/dist/chat/question.d.ts

@@ -1,9 +0,0 @@
-import { type ReactElement } from 'react';
-import type { MdRuntimeClient } from '../client.js';
-import type { ChatQuestion } from './questions.js';
-export declare function forgetAnswers(client: MdRuntimeClient, conversation: string, interaction?: string): Promise<void>;
-export type ChatQuestionCardProps = {
-    readonly question: ChatQuestion;
-};
-export declare function ChatQuestionCard({ question }: ChatQuestionCardProps): ReactElement;
-//# sourceMappingURL=question.d.ts.map

package/dist/chat/question.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"question.d.ts","sourceRoot":"","sources":["../../src/chat/question.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAwB,KAAK,YAAY,EAAE,MAAM,OAAO,CAAC;AAGhE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAMpD,OAAO,KAAK,EAAa,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAO9D,wBAAsB,aAAa,CACjC,MAAM,EAAE,eAAe,EACvB,YAAY,EAAE,MAAM,EACpB,WAAW,SAAK,GACf,OAAO,CAAC,IAAI,CAAC,CAOf;AAeD,MAAM,MAAM,qBAAqB,GAAG;IAClC,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAC;CACjC,CAAC;AAEF,wBAAgB,gBAAgB,CAAC,EAAE,QAAQ,EAAE,EAAE,qBAAqB,GAAG,YAAY,CAmHlF"}