@agentshouse/mdruntime 0.1.0-c94cfdbdb6f68 → 0.1.0-c95f0f04f2113

package/dist/store/records.js

@@ -0,0 +1,408 @@
+import { composedOf } from '../collection.js';
+import { binaryLocalId } from '../identity.js';
+const FILE = '\u0000file';
+function batchFacts(batch) {
+    return { paths: batch.changes.map(({ path }) => path), moving: batch.between !== undefined };
+}
+function batchFiles(batch) {
+    return batch.changes.flatMap((change) => (change.kind === 'binary' ? [change.localId] : []));
+}
+function draftFiles(drafts) {
+    return drafts.flatMap(({ parts }) => (parts.file === undefined ? [] : [parts.file.localId]));
+}
+function roomDraftRow(record) {
+    return { path: record.path, record: JSON.stringify(record), files: draftFiles([record]) };
+}
+function authoredRows({ locator, queue, stored, founded, saved, roomDrafts, consumedRoomDrafts, }) {
+    const held = new Set((stored ?? []).map(({ id }) => id));
+    return {
+        locator,
+        ...(queue === undefined
+            ? {}
+            : {
+                order: queue.map(({ id }) => id),
+                added: queue
+                    .filter(({ id }) => !held.has(id))
+                    .map((batch) => {
+                    const drafts = saved?.get(batch.id) ?? [];
+                    return {
+                        id: batch.id,
+                        batch: JSON.stringify(batch),
+                        state: JSON.stringify({
+                            drafts,
+                            submission: { state: 'waiting' },
+                            lost: false,
+                        }),
+                        files: [...batchFiles(batch), ...draftFiles(drafts)],
+                        ...batchFacts(batch),
+                    };
+                }),
+            }),
+        ...(founded === undefined
+            ? {}
+            : {
+                founded: founded.map((batch) => ({
+                    id: batch.id,
+                    batch: JSON.stringify(batch),
+                    files: batchFiles(batch),
+                    ...batchFacts(batch),
+                })),
+            }),
+        ...(roomDrafts === undefined ? {} : { roomDrafts: roomDrafts.map(roomDraftRow) }),
+        ...(consumedRoomDrafts === undefined ? {} : { consumedRoomDrafts }),
+    };
+}
+function marked(value) {
+    return typeof value === 'object' && value !== null && FILE in value;
+}
+function keyed(keys, value) {
+    const stored = [];
+    const files = [];
+    const record = JSON.stringify(value, (_name, held) => {
+        if (!(held instanceof Blob))
+            return held;
+        let key = keys.get(held);
+        if (key === undefined) {
+            key = binaryLocalId();
+            keys.set(held, key);
+        }
+        stored.push({ key, blob: held });
+        files.push(key);
+        return { [FILE]: key, type: held.type };
+    });
+    return { record, files, stored };
+}
+async function filed(value, read) {
+    if (Array.isArray(value))
+        return Promise.all(value.map((item) => filed(item, read)));
+    if (marked(value))
+        return read(value[FILE], value.type);
+    if (typeof value !== 'object' || value === null)
+        return value;
+    const restored = {};
+    for (const [name, item] of Object.entries(value))
+        restored[name] = await filed(item, read);
+    return restored;
+}
+function roomOf(row) {
+    return {
+        record: { ...JSON.parse(row.record), key: row.key },
+        indexed: row.indexed,
+        documents: row.documents,
+    };
+}
+function json(value, fallback) {
+    return value === undefined ? fallback : JSON.parse(value);
+}
+export function openRuntimeStore(authored) {
+    const keys = new WeakMap();
+    const read = async (key, type) => {
+        const blob = await authored.ask({ kind: 'authored.file', key, type });
+        keys.set(blob, key);
+        return blob;
+    };
+    const restored = async (records) => Promise.all(records.map(async (record) => (await filed(JSON.parse(record), read))));
+    const amend = async (locator, id, amendment) => {
+        await authored.ask({
+            kind: 'authored.amend',
+            locator,
+            id,
+            amendment: JSON.stringify(amendment),
+        });
+    };
+    const fact = (name) => authored.ask({ kind: 'authored.fact', name });
+    const changed = new Map();
+    const change = (key) => changed.set(key, (changed.get(key) ?? 0) + 1);
+    return {
+        opened() {
+            return authored.ask({ kind: 'replica.open' });
+        },
+        async rooms(locators) {
+            const held = await authored.ask({ kind: 'replica.rooms', locators: locators ?? null });
+            return held.map(roomOf);
+        },
+        async room(locator) {
+            const { room, queue } = await authored.ask({ kind: 'replica.room', locator });
+            return {
+                room: room === null ? null : { ...roomOf(room), overlaid: new Set(room.overlaid) },
+                queue: queue.map(({ batch, state }) => ({
+                    batch: JSON.parse(batch),
+                    state: JSON.parse(state),
+                })),
+            };
+        },
+        async covering() {
+            const { rooms, queues } = await authored.ask({ kind: 'replica.covering' });
+            return {
+                rooms: new Map(rooms.map(({ locator, ...room }) => [locator, room])),
+                queues: new Map(queues.map(({ locator, ids }) => [locator, ids])),
+            };
+        },
+        offline(locator) {
+            return authored.ask({ kind: 'replica.offline', locator });
+        },
+        async held() {
+            const { held, staged } = await authored.ask({ kind: 'replica.held' });
+            return { held: new Set(held), staged: new Set(staged) };
+        },
+        async status() {
+            const { queued, lastCompleted, changes, resets, returned } = await authored.ask({
+                kind: 'authored.status',
+            });
+            return {
+                queued,
+                lastCompleted: json(lastCompleted ?? undefined, null),
+                unsent: changes.map(({ locator, path }) => ({ room: locator, path })),
+                resets,
+                returned: returned.map((record) => JSON.parse(record)),
+            };
+        },
+        async batch(locator, id) {
+            const held = await authored.ask({ kind: 'authored.batch', locator, id });
+            return held === null ? null : JSON.parse(held);
+        },
+        order(locator) {
+            return authored.ask({ kind: 'authored.order', locator });
+        },
+        queued() {
+            return authored.ask({ kind: 'authored.queued' });
+        },
+        async moving() {
+            const { queues, pending } = await authored.ask({ kind: 'authored.moving' });
+            return {
+                queued: new Map(queues.map(({ locator, ids }) => [locator, ids])),
+                moving: pending.map(({ locator, batch, state }) => ({
+                    locator,
+                    batch: JSON.parse(batch),
+                    state: JSON.parse(state),
+                })),
+            };
+        },
+        async pending(locator, id) {
+            const { state, room } = await authored.ask({ kind: 'authored.pending', locator, id });
+            return { state: state === null ? undefined : JSON.parse(state), room };
+        },
+        async facts() {
+            const held = await authored.ask({ kind: 'replica.facts' });
+            return {
+                lastCompleted: json(held.lastCompleted, null),
+                providerLimits: json(held.providerLimits, []),
+                capabilities: json(held.capabilities, []),
+                member: json(held.member, null),
+                targets: json(held.targets, {}),
+                conversationList: json(held.conversationList, null),
+                conversationCursor: json(held.conversationCursor, null),
+            };
+        },
+        async presentation(app) {
+            const held = await authored.ask({ kind: 'replica.presentation', app });
+            return held === null ? undefined : JSON.parse(held);
+        },
+        async demote() {
+            await authored.ask({ kind: 'replica.demote' });
+        },
+        query(plan, rooms, budget) {
+            return authored.ask({ kind: 'replica.query', plan, rooms, budget });
+        },
+        changes(keys) {
+            return keys.reduce((total, key) => total + (changed.get(key) ?? 0), 0);
+        },
+        entries(key, view, paths) {
+            return authored.ask({ kind: 'replica.entries', key, view, paths });
+        },
+        typed(key, view, paths) {
+            return authored.ask({ kind: 'replica.typed', key, view, paths });
+        },
+        referrers(key, view, targets) {
+            return authored.ask({ kind: 'replica.referrers', key, view, targets });
+        },
+        folders(key, view, paths) {
+            return authored.ask({ kind: 'replica.folders', key, view, paths });
+        },
+        typedWithin(key, view, roots, within) {
+            return authored.ask({ kind: 'replica.typedWithin', key, view, roots, within });
+        },
+        stage(record, composition, page) {
+            return authored.ask({
+                kind: 'replica.stage',
+                locator: record.locator,
+                transfer: record.transfer,
+                key: record.key,
+                fingerprint: composedOf(composition).fingerprint,
+                entries: page.entries,
+                folders: page.folders,
+                part: page.part ?? null,
+            });
+        },
+        resume(record, composition, parts, published) {
+            return authored.ask({
+                kind: 'replica.resume',
+                locator: record.locator,
+                transfer: record.transfer,
+                fingerprint: composedOf(composition).fingerprint,
+                parts,
+                published,
+            });
+        },
+        async refresh(key, composition, page) {
+            await authored.ask({
+                kind: 'replica.refresh',
+                key,
+                composed: composedOf(composition),
+                entries: page.entries,
+                removals: page.removals,
+                folders: page.folders,
+                folderRemovals: page.folderRemovals,
+            });
+        },
+        async unrefresh(key) {
+            await authored.ask({ kind: 'replica.unrefresh', key });
+        },
+        commit({ rooms, writes = [], files = [], whole = false }) {
+            for (const room of rooms)
+                change(room.key);
+            return authored.ask({
+                kind: 'replica.commit',
+                ...(writes.length === 0 && files.length === 0
+                    ? {}
+                    : { authored: { writes: writes.map(authoredRows), files, whole } }),
+                rooms,
+            });
+        },
+        async fence(locators) {
+            await authored.ask({ kind: 'replica.fence', locators });
+        },
+        async erase(locator, limit) {
+            return (await authored.ask({ kind: 'replica.erase', locator, limit })).remaining;
+        },
+        async abandon(locator) {
+            await authored.ask({ kind: 'replica.abandon', locator });
+        },
+        async unfence(locators) {
+            return new Set(await authored.ask({ kind: 'replica.unfence', locators }));
+        },
+        async release(key) {
+            await authored.ask({ kind: 'replica.release', key });
+        },
+        async rederive(key, composition, bytes, ms, floor) {
+            change(key);
+            return authored.ask({
+                kind: 'replica.rederive',
+                key,
+                composed: composedOf(composition),
+                bytes,
+                ms,
+                floor,
+            });
+        },
+        async fact(name, value) {
+            await authored.ask({ kind: 'replica.fact', name, value: JSON.stringify(value) });
+        },
+        submit(locator, id, submission, lost) {
+            return amend(locator, id, { submission, lost });
+        },
+        keepUpload(locator, id, upload) {
+            return amend(locator, id, { upload });
+        },
+        async roomDrafts(locator, paths) {
+            const held = await authored.ask({
+                kind: 'authored.roomDrafts',
+                locator: locator ?? null,
+                paths: paths ?? null,
+            });
+            return held.map((record) => JSON.parse(record));
+        },
+        async present(record) {
+            await authored.ask({
+                kind: 'replica.present',
+                app: record.app,
+                value: JSON.stringify(record.value ?? null),
+            });
+        },
+        conversations(conversations) {
+            return authored.ask({ kind: 'conversation.held', conversations: conversations ?? null });
+        },
+        async keepMessages(write) {
+            await authored.ask({ kind: 'conversation.keep', ...write });
+        },
+        messageWindow(conversation, limit, before, phrase = null) {
+            return authored.ask({ kind: 'conversation.window', conversation, limit, before, phrase });
+        },
+        messageCount(conversation, phrase = null) {
+            return authored.ask({ kind: 'conversation.count', conversation, phrase });
+        },
+        turnArrived(conversation, turn) {
+            return authored.ask({ kind: 'conversation.turn', conversation, turn });
+        },
+        conversationRows(conversations) {
+            return authored.ask({ kind: 'conversation.rows', conversations });
+        },
+        jobMarkers(conversation) {
+            return authored.ask({ kind: 'conversation.jobs', conversation });
+        },
+        async dropConversations(conversations) {
+            await authored.ask({ kind: 'conversation.drop', conversations });
+        },
+        async chatDrafts() {
+            const records = await authored.ask({ kind: 'authored.chatDrafts' });
+            return records.map((record) => JSON.parse(record));
+        },
+        async chatDraft(conversation) {
+            const record = await authored.ask({ kind: 'authored.chatDraft.read', conversation });
+            return record === null ? null : JSON.parse(record);
+        },
+        async keepChatDrafts(records) {
+            await authored.ask({
+                kind: 'authored.chatDraft',
+                kept: records.map((record) => ({
+                    conversation: record.conversation,
+                    record: JSON.stringify(record),
+                })),
+                dropped: [],
+            });
+        },
+        async dropChatDraft(conversation) {
+            await authored.ask({ kind: 'authored.chatDraft', kept: [], dropped: [conversation] });
+        },
+        async calls() {
+            return restored(await authored.ask({ kind: 'authored.calls' }));
+        },
+        async keepCall(record) {
+            const { stored, ...kept } = keyed(keys, record);
+            await authored.ask({
+                kind: 'authored.call',
+                operation: record.operation,
+                kept,
+                files: stored,
+            });
+        },
+        async dropCall(operation) {
+            await authored.ask({ kind: 'authored.call', operation, kept: null, files: [] });
+        },
+        async keepRoomDraft(record, files) {
+            const { path, ...kept } = roomDraftRow(record);
+            await authored.ask({
+                kind: 'authored.roomDraft',
+                locator: record.locator,
+                path,
+                kept,
+                files,
+            });
+        },
+        async discardRoomDraft(locator, path) {
+            await authored.ask({ kind: 'authored.roomDraft', locator, path, kept: null, files: [] });
+        },
+        fences() {
+            return authored.ask({ kind: 'authored.fences' });
+        },
+        generation() {
+            return fact('generation');
+        },
+        async rememberGeneration(value) {
+            await authored.ask({ kind: 'authored.remember', name: 'generation', value });
+        },
+        file(key, type) {
+            return authored.ask({ kind: 'authored.file', key, type });
+        },
+    };
+}

package/dist/store/room-held.d.ts

@@ -0,0 +1,8 @@
+export type RoomHeld<T> = {
+    of(locator: string, key: string): T | undefined;
+    hold(locator: string, key: string, value: T): void;
+    drop(locator: string, key: string): void;
+    forget(locator: string): void;
+};
+export declare function createRoomHeld<T>(): RoomHeld<T>;
+//# sourceMappingURL=room-held.d.ts.map

package/dist/store/room-held.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"room-held.d.ts","sourceRoot":"","sources":["../../src/store/room-held.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI;IACxB,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS,CAAC;IAChD,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;IACnD,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IACzC,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B,CAAC;AAEF,wBAAgB,cAAc,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,CAgB/C"}

package/dist/store/room-held.js

@@ -0,0 +1,17 @@
+export function createRoomHeld() {
+    const rooms = new Map();
+    return {
+        of: (locator, key) => rooms.get(locator)?.get(key),
+        hold(locator, key, value) {
+            const room = rooms.get(locator) ?? new Map();
+            room.set(key, value);
+            rooms.set(locator, room);
+        },
+        drop(locator, key) {
+            rooms.get(locator)?.delete(key);
+        },
+        forget(locator) {
+            rooms.delete(locator);
+        },
+    };
+}

package/dist/store/space.d.ts

@@ -0,0 +1,11 @@
+import type { RuntimeDatabase } from '../tables.js';
+export type Space = {
+    full(): boolean;
+    fill(): boolean;
+    probing(): boolean;
+    probeEachMinute(): void;
+    probe(): Promise<boolean>;
+    stop(): void;
+};
+export declare function createSpace(database: RuntimeDatabase, freed: () => void): Space;
+//# sourceMappingURL=space.d.ts.map

package/dist/store/space.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"space.d.ts","sourceRoot":"","sources":["../../src/store/space.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAEpD,MAAM,MAAM,KAAK,GAAG;IAClB,IAAI,IAAI,OAAO,CAAC;IAChB,IAAI,IAAI,OAAO,CAAC;IAChB,OAAO,IAAI,OAAO,CAAC;IACnB,eAAe,IAAI,IAAI,CAAC;IACxB,KAAK,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;IAC1B,IAAI,IAAI,IAAI,CAAC;CACd,CAAC;AAEF,wBAAgB,WAAW,CAAC,QAAQ,EAAE,eAAe,EAAE,KAAK,EAAE,MAAM,IAAI,GAAG,KAAK,CA4C/E"}

package/dist/store/space.js

@@ -0,0 +1,43 @@
+export function createSpace(database, freed) {
+    let full = false;
+    let probing = null;
+    let testing = null;
+    function probe() {
+        testing ??= database.ask({ kind: 'space.probe' }).then(() => {
+            testing = null;
+            if (full) {
+                full = false;
+                if (probing !== null)
+                    clearInterval(probing);
+                probing = null;
+                freed();
+            }
+            return true;
+        }, () => {
+            testing = null;
+            return false;
+        });
+        return testing;
+    }
+    return {
+        full: () => full,
+        fill() {
+            if (full)
+                return false;
+            full = true;
+            return true;
+        },
+        probing: () => probing !== null,
+        probeEachMinute() {
+            // A device whose storage filled after its install tries a write each minute, so space freed elsewhere ends its read-only mode without a Retry.
+            probing = setInterval(() => {
+                void probe();
+            }, 60_000);
+        },
+        probe,
+        stop() {
+            if (probing !== null)
+                clearInterval(probing);
+        },
+    };
+}

package/dist/store/watchers.d.ts

@@ -0,0 +1,17 @@
+export type Watcher = {
+    held(): boolean;
+    stop(): void;
+    answer(value: unknown): void;
+};
+export type Watching = 'all' | 'waiting' | 'ready';
+type Watchers = {
+    publication(work: () => Promise<void>): Promise<void>;
+    owing<T>(topic: string, add: (owed: T | undefined) => T, work: (owed: T) => Promise<void>): Promise<void>;
+    watch(topic: string, notify: (value: unknown) => void): Watcher;
+    watching(topic: string, which?: Watching): readonly Watcher[];
+    tell(topic: string, value: unknown): void;
+    close(): void;
+};
+export declare function createWatchers(unpublished: (error: unknown) => void): Watchers;
+export {};
+//# sourceMappingURL=watchers.d.ts.map

package/dist/store/watchers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"watchers.d.ts","sourceRoot":"","sources":["../../src/store/watchers.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,OAAO,GAAG;IACpB,IAAI,IAAI,OAAO,CAAC;IAChB,IAAI,IAAI,IAAI,CAAC;IACb,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;CAC9B,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG,KAAK,GAAG,SAAS,GAAG,OAAO,CAAC;AAMnD,KAAK,QAAQ,GAAG;IACd,WAAW,CAAC,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACtD,KAAK,CAAC,CAAC,EACL,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,CAAC,IAAI,EAAE,CAAC,GAAG,SAAS,KAAK,CAAC,EAC/B,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,GAC/B,OAAO,CAAC,IAAI,CAAC,CAAC;IACjB,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GAAG,OAAO,CAAC;IAChE,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,QAAQ,GAAG,SAAS,OAAO,EAAE,CAAC;IAC9D,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;IAC1C,KAAK,IAAI,IAAI,CAAC;CACf,CAAC;AAEF,wBAAgB,cAAc,CAAC,WAAW,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GAAG,QAAQ,CA6D9E"}

package/dist/store/watchers.js

@@ -0,0 +1,57 @@
+export function createWatchers(unpublished) {
+    let published = Promise.resolve();
+    const topics = new Map();
+    const owed = new Map();
+    function publication(work) {
+        published = published.then(work).catch(unpublished);
+        return published;
+    }
+    return {
+        publication,
+        owing(topic, add, work) {
+            const held = owed.get(topic);
+            if (held !== undefined) {
+                held.value = add(held.value);
+                return held.shown;
+            }
+            const owing = { value: add(undefined), shown: Promise.resolve() };
+            owed.set(topic, owing);
+            owing.shown = publication(async () => {
+                if (owed.get(topic) === owing)
+                    owed.delete(topic);
+                await work(owing.value);
+            });
+            return owing.shown;
+        },
+        watch(topic, notify) {
+            const held = topics.get(topic) ?? new Set();
+            topics.set(topic, held);
+            const watcher = {
+                ready: false,
+                held: () => topics.get(topic)?.has(watcher) === true,
+                stop() {
+                    const on = topics.get(topic);
+                    on?.delete(watcher);
+                    if (on?.size === 0)
+                        topics.delete(topic);
+                },
+                answer(value) {
+                    watcher.ready = true;
+                    notify(value);
+                },
+            };
+            held.add(watcher);
+            return watcher;
+        },
+        watching(topic, which = 'all') {
+            return [...(topics.get(topic) ?? [])].filter(({ ready }) => which === 'all' || ready === (which === 'ready'));
+        },
+        tell(topic, value) {
+            for (const watcher of topics.get(topic) ?? [])
+                watcher.answer(value);
+        },
+        close() {
+            topics.clear();
+        },
+    };
+}

package/dist/store/writes.d.ts

@@ -0,0 +1,24 @@
+import type { Composition } from '../collection.js';
+import type { RefreshedPage, RuntimeStore } from './records.js';
+export type InstallHold = {
+    take(): void;
+    release(): void;
+};
+type Writes = {
+    exclusive<T>(work: () => Promise<T>): Promise<T>;
+    gathered<I, T>(key: string, input: I, merge: (earlier: I, later: I) => I | null, work: (input: I) => Promise<T>): Promise<T>;
+    written(): Promise<unknown>;
+    startingWrite<T>(work: () => Promise<T>): Promise<T>;
+    finishingWrite<T>(work: () => Promise<T>): Promise<T>;
+    ahead<T>(work: (hold: InstallHold) => Promise<T>): Promise<T>;
+    rederive(local: RuntimeStore, key: number, composition: Composition): Promise<{
+        readonly done: boolean;
+        readonly text: number;
+    }>;
+    refreshPage(local: RuntimeStore, key: number, composition: Composition, page: RefreshedPage): Promise<void>;
+    stageBytes(): number;
+    deriveBytes(): number;
+};
+export declare function createWrites(): Writes;
+export {};
+//# sourceMappingURL=writes.d.ts.map

package/dist/store/writes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"writes.d.ts","sourceRoot":"","sources":["../../src/store/writes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AA8BhE,MAAM,MAAM,WAAW,GAAG;IAAE,IAAI,IAAI,IAAI,CAAC;IAAC,OAAO,IAAI,IAAI,CAAA;CAAE,CAAC;AAE5D,KAAK,MAAM,GAAG;IACZ,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IACjD,QAAQ,CAAC,CAAC,EAAE,CAAC,EACX,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,CAAC,EACR,KAAK,EAAE,CAAC,OAAO,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,CAAC,GAAG,IAAI,EACzC,IAAI,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,GAC7B,OAAO,CAAC,CAAC,CAAC,CAAC;IACd,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;IAC5B,aAAa,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IACrD,cAAc,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IACtD,KAAK,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,IAAI,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IAC9D,QAAQ,CACN,KAAK,EAAE,YAAY,EACnB,GAAG,EAAE,MAAM,EACX,WAAW,EAAE,WAAW,GACvB,OAAO,CAAC;QAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC9D,WAAW,CACT,KAAK,EAAE,YAAY,EACnB,GAAG,EAAE,MAAM,EACX,WAAW,EAAE,WAAW,EACxB,IAAI,EAAE,aAAa,GAClB,OAAO,CAAC,IAAI,CAAC,CAAC;IACjB,UAAU,IAAI,MAAM,CAAC;IACrB,WAAW,IAAI,MAAM,CAAC;CACvB,CAAC;AAcF,wBAAgB,YAAY,IAAI,MAAM,CAqHrC"}