@agentshouse/mdruntime 0.1.0-cd26b960b7262 → 0.1.0-cd30853a1b15e

package/README.md

@@ -12,14 +12,14 @@ npm install @agentshouse/mdruntime
 
 ## Entries
 
-| Entry                           | For                                                                                            |
-| ------------------------------- | ---------------------------------------------------------------------------------------------- |
-| `@agentshouse/mdruntime/client` | The host's client: `connectMdRuntime(port)`                                                    |
-| `@agentshouse/mdruntime/host`   | The host that serves a Runtime: `serveMdRuntime`                                               |
-| `@agentshouse/mdruntime`        | Shared types                                                                                   |
-| `@agentshouse/mdruntime/memory` | Tests: `createMemoryAdapter`, an in-memory Adapter                                             |
-| `@agentshouse/mdruntime/tables` | The host's database: the Authored store's and opened files' tables, `answerRuntime`            |
-| `@agentshouse/mdruntime/react`  | React over the client: `useObserve`, `useSave`; `useReading`, a reader of an expectation store |
+| Entry                           | For                                                                                                                                                             |
+| ------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `@agentshouse/mdruntime/client` | The host's client: `connectMdRuntime(port)`                                                                                                                     |
+| `@agentshouse/mdruntime/host`   | The host that serves a Runtime: `serveMdRuntime`                                                                                                                |
+| `@agentshouse/mdruntime`        | Shared types                                                                                                                                                    |
+| `@agentshouse/mdruntime/memory` | Tests: `createMemoryAdapter`, an in-memory Adapter                                                                                                              |
+| `@agentshouse/mdruntime/tables` | The host's database: `formatted` lays it out for a device format, keeping the Authored store's tables and creating any it lacks, and `answerRuntime` answers it |
+| `@agentshouse/mdruntime/react`  | React over the client: `useObserve`, `useSave`; `useExpected`, a reader of an expectation store; `useLane`, a reader of an act lane                             |
 
 ## Usage
 
@@ -33,24 +33,26 @@ const rooms = await runtime.rooms();
 const notes = await runtime.query({ types: ['note'], select: 'all', limit: 20 });
 ```
 
-`observe('storage-loss')` reports `null` or the stable code
-`storage-loss` when unsynchronized Room Drafts and Pending Changes were lost.
-The host supplies the user-facing wording.
+`observe('storage-loss')` reports `null`, the stable code `storage-loss` when
+unsynchronized Room Drafts and Pending Changes were lost, or `visit` while the host holds
+the database in memory, which ends with the visit; the readiness `persistence` answer is then
+`memory`. The host supplies the user-facing wording.
 
 In House the bridge object the page holds as `window.houseBridge` places the Chat, which
-House serves with the page: install and bundle nothing for it. Mount it in an element,
-themed by CSS custom properties on that element, docked at a third of the window:
+House serves with the page: install and bundle nothing for it. Mount it in an element it
+fills, where it lays out the User's chats by the element's width, themed by CSS custom
+properties on that element, or as the Chat button, House's dot that opens it in a sheet:
 
 ```ts
-const chat = await window.houseBridge.chat.mount(element, { width: '1/3', showChats: true });
+const chat = await window.houseBridge.chat.mount(element, { conversation });
 element.style.setProperty('--chat-accent', '#2a6cf0');
-chat.update({ width: 'full', showChats: true });
-chat.unmount();
+chat.update({ conversation: null, agent });
+const button = await window.houseBridge.chat.mountButton({});
+button.open({ agent });
 ```
 
-The rules an App's agent follows, including Local Query, search, Room
-Draft, Save and the Chat, are the `apps/` pages of House's Guide, which House's
-`guide/open` opens.
+The rules an App's agent follows, including Local Query, search, Room Draft, Save and the
+Chat, are the `apps/` pages of House's Guide, which House's `guide/open` opens.
 
 ## License
 

package/dist/acceptance.d.ts

@@ -1,6 +1,3 @@
 import type { Runtime } from './runtime.js';
-import type { RuntimeStore } from './store.js';
-export declare function unpair(runtime: Runtime, local: RuntimeStore): Promise<void>;
 export declare function submitLater(runtime: Runtime, locator: string): void;
-export declare function submitAll(runtime: Runtime): Promise<void>;
 //# sourceMappingURL=acceptance.d.ts.map

package/dist/acceptance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"acceptance.d.ts","sourceRoot":"","sources":["../src/acceptance.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAG5C,OAAO,KAAK,EAAE,YAAY,EAAe,MAAM,YAAY,CAAC;AAkO5D,wBAAsB,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAgBjF;AA+ND,wBAAgB,WAAW,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,QAK5D;AA4BD,wBAAsB,SAAS,CAAC,OAAO,EAAE,OAAO,iBAM/C"}
+{"version":3,"file":"acceptance.d.ts","sourceRoot":"","sources":["../src/acceptance.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AA0V5C,wBAAgB,WAAW,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,QAK5D"}

package/dist/acceptance.js

@@ -1,18 +1,19 @@
+import { refusalError } from './failure.js';
 import { changeSet } from './change-set.js';
+import { declared } from './declaration.js';
 import { leaving as leavingIn, partnerOf } from './change.js';
 import { olderThan, showing } from './install.js';
-import { readable } from './listing.js';
+import { scoped } from './models.js';
+import { answered, settle } from './queue.js';
 import { refuse } from './refusal.js';
-import { landed, returnedPaths, returning, slicing, touchedBy } from './replica.js';
-import { batchFile, landedWhole, settle, settlement, sliceAt, together, unpairing, withdrawable, } from './saves.js';
+import { returnedPaths, returning, slicing } from './replica.js';
+import { batchFile } from './saves.js';
 import { rest, roomUnreadable, statusShown } from './shown.js';
+import { advanced, withhold } from './sync.js';
 import { unconfirmed } from './transfer.js';
 import { stepped } from './turn.js';
-function pendingKey(locator, id) {
-    return `${locator}\u0000${id}`;
-}
 async function mark(runtime, local, locator, batch, submission, lost) {
-    const { store, socket } = runtime;
+    const { store, socket, presence } = runtime;
     const partner = partnerOf(batch, locator);
     for (const held of partner === null ? [locator] : [locator, partner]) {
         const { state, room } = await local.pending(held, batch.id);
@@ -22,116 +23,86 @@ async function mark(runtime, local, locator, batch, submission, lost) {
             continue;
         }
         await local.submit(held, batch.id, submission, lost);
-        if (store.fences.has(held))
+        if (presence.lost(held))
             continue;
         if (room)
             store.changed(changeSet(held, { queue: true }));
     }
     statusShown(runtime);
 }
-async function keepUpload({ store, socket }, local, locator, identifier, upload) {
+async function keepUpload({ socket, presence }, local, locator, identifier, upload) {
     if (!socket.continuing())
         throw new Error();
     await local.keepUpload(locator, identifier, upload);
-    if (store.fences.has(locator))
+    if (presence.lost(locator))
         throw new Error();
     if (!socket.continuing())
         throw new Error();
 }
-function leaving(batch, result) {
-    return {
-        batch,
-        returned: {
-            kind: result.kind,
-            code: result.code,
-            fields: result.fields,
-            retryable: result.retryable,
-        },
-    };
-}
-function logAccepted({ journal }, locator, submitted, accepted) {
-    journal.record(`outcome ${locator} ${submitted.id} accepted ${accepted.roomVersion}` +
-        (accepted.author === undefined ? '' : ` author ${accepted.author}`) +
-        (accepted.time === undefined ? '' : ` time ${accepted.time}`));
-}
-function settling(acceptance) {
-    return acceptance !== null && 'apply' in acceptance;
-}
-function failureOf(acceptance) {
-    return settling(acceptance) ? null : acceptance;
+function restands(adoptions) {
+    return adoptions.flatMap((one) => (one === null || !('record' in one) ? [] : [one]));
 }
-async function acceptance(runtime, room, local, submitted, accepted) {
+async function adoption(runtime, room, current, local, submitted, accepted) {
     const { store, socket } = runtime;
     if (!socket.continuing())
         return unconfirmed;
-    const work = await store.work(room.locator);
-    const current = work.replica;
     if (current === undefined || !current.queue.some((batch) => batch.id === submitted.id)) {
         return null;
     }
     const held = current.record.roomVersion;
-    logAccepted(runtime, room.locator, submitted, accepted);
     let record = current.record;
-    let changes;
+    let adopted;
     if (!socket.reads.reached(room.locator, held, accepted.roomVersion) &&
         !olderThan(runtime, room.locator, accepted.roomVersion, held)) {
         const paths = [...returnedPaths(submitted, accepted)];
         const confirmedLayer = await stepped(slicing(await local.entries(record.key, 'confirmed', paths), paths));
-        const back = await stepped(returning(confirmedLayer, submitted, accepted, accepted.roomVersion, store.composed(record)));
+        adopted = await stepped(returning(confirmedLayer, submitted, accepted, accepted.roomVersion, store.composed(record)));
         record = {
             ...record,
             roomVersion: socket.follows(room.locator, held, accepted.roomVersion)
                 ? accepted.roomVersion
                 : held,
         };
-        changes = back;
     }
-    const settled = await settlement(runtime, local, room.locator, work, record, current.queue.filter((batch) => batch.id !== submitted.id), { room: true, ...(changes === undefined ? {} : { changes }) });
     const reached = record.roomVersion;
     return {
-        ...settled,
-        apply(answer) {
-            const set = settled.apply(answer);
+        locator: room.locator,
+        record,
+        accepted: submitted.id,
+        ...(adopted === undefined ? {} : { adopted }),
+        after() {
             showing(runtime, room.locator, accepted.roomVersion, reached);
-            readable(runtime, room);
-            return set;
+            runtime.presence.readable(room.locator);
         },
     };
 }
-async function adoptedTogether(runtime, local, acceptances) {
-    const settlements = acceptances.filter(settling);
-    if (settlements.length > 0) {
-        const set = await together(runtime, local, settlements);
-        void statusShown(runtime);
-        void runtime.store.changed(set);
-    }
-    await unpair(runtime, local);
-}
 async function adopted(runtime, room, local, submitted, accepted) {
-    const failed = await runtime.store.exclusive(async () => {
-        const adopting = await acceptance(runtime, room, local, submitted, accepted);
-        await adoptedTogether(runtime, local, [adopting]);
-        return failureOf(adopting);
+    let kept = true;
+    await settle(runtime, [room.locator], async (held) => {
+        const adopting = await adoption(runtime, room, held.get(room.locator)?.replica, local, submitted, accepted);
+        kept = adopting !== unconfirmed;
+        return restands([adopting]);
     });
-    return failed === null;
+    return kept;
 }
 async function adoptedMove(runtime, room, partner, local, submitted, accepted) {
-    const { store, socket } = runtime;
-    const other = socket.rooms.discovered(partner);
-    const failed = await store.exclusive(async () => {
-        const left = await acceptance(runtime, room, local, submitted, accepted);
-        const arriving = (await store.replica(partner))?.queue.find((batch) => batch.id === submitted.id);
+    const other = runtime.presence.room(partner);
+    let kept = true;
+    await settle(runtime, [room.locator, partner], async (held) => {
+        const left = await adoption(runtime, room, held.get(room.locator)?.replica, local, submitted, accepted);
+        const there = held.get(partner)?.replica;
+        const arriving = there?.queue.find((batch) => batch.id === submitted.id);
         const arrived = other === undefined || arriving === undefined || accepted.destination === undefined
             ? null
-            : await acceptance(runtime, other, local, arriving, {
+            : await adoption(runtime, other, there, local, arriving, {
                 kind: 'accepted',
                 ...accepted.destination,
             });
-        await adoptedTogether(runtime, local, [left, arrived]);
-        return failureOf(left);
+        kept = left !== unconfirmed;
+        return restands([left, arrived]);
     });
     submitLater(runtime, partner);
-    return failed === null;
+    return kept;
 }
 async function behindIn({ store }, locator, batch) {
     const local = await store.open();
@@ -141,38 +112,12 @@ async function behindIn({ store }, locator, batch) {
     ]);
     return room ? order.indexOf(batch.id) > 0 : order.length > 0;
 }
-async function unpaired(local, skipped) {
-    const { queued, moving } = await local.moving();
-    for (const { locator, batch, state } of moving) {
-        const partner = partnerOf(batch, locator);
-        if (partner === null || skipped.has(pendingKey(locator, batch.id)))
-            continue;
-        if (queued.get(partner)?.includes(batch.id) === true)
-            continue;
-        if (!leavingIn(batch, locator) || withdrawable(new Map([[batch.id, state]]))(batch)) {
-            return { locator, batch };
-        }
-    }
-    return null;
-}
-export async function unpair(runtime, local) {
-    const { store, socket } = runtime;
-    const handled = new Set();
-    for (let held = await unpaired(local, handled); held !== null && socket.continuing(); held = await unpaired(local, handled)) {
-        const { locator, batch } = held;
-        handled.add(pendingKey(locator, batch.id));
-        store.changed(await together(runtime, local, [await unpairing(runtime, local, locator, [batch])]));
-    }
-    if (handled.size === 0)
-        return;
-    statusShown(runtime);
-}
 async function submitRoom(runtime, room, local, authorized, progress, signal) {
-    const { store, socket, journal, advanced, withhold } = runtime;
+    const { store, socket, presence } = runtime;
     while (socket.continuing() &&
         socket.session.now().authorization !== undefined &&
         !signal.aborted) {
-        const headId = (await local.order(room.locator)).find((id) => store.landed.of(room.locator, id) === undefined);
+        const headId = (await local.order(room.locator)).find((id) => store.conflicted.of(room.locator, id) === undefined);
         if (headId === undefined)
             return 'done';
         const [head, pending] = await Promise.all([
@@ -201,27 +146,24 @@ async function submitRoom(runtime, room, local, authorized, progress, signal) {
         }
         if (socket.writesHeld()) {
             progress.complete = false;
-            journal.record(`submission ${room.locator} ${head.id} held`);
             return 'done';
         }
         const lost = earlier || submission.state === 'submitted';
         let result;
-        journal.record(`submission ${room.locator} ${head.id}`);
         await store.exclusive(() => mark(runtime, local, room.locator, head, { state: 'submitted' }, lost));
-        if (socket.session.now().paused || store.fences.has(room.locator))
+        if (socket.session.now().paused || presence.lost(room.locator))
             return 'done';
         if (signal.aborted || socket.writesHeld()) {
             await store.exclusive(() => mark(runtime, local, room.locator, head, submission, earlier));
             if (signal.aborted)
                 return 'done';
             progress.complete = false;
-            journal.record(`submission ${room.locator} ${head.id} held`);
             return 'done';
         }
         const opensBefore = socket.session.now().openSignals;
         const answeredHere = socket.awaitingAnswer(room.locator);
         const answeredThere = partner === null ? () => { } : socket.awaitingAnswer(partner);
-        const answered = () => {
+        const heard = () => {
             answeredHere();
             answeredThere();
         };
@@ -233,29 +175,33 @@ async function submitRoom(runtime, room, local, authorized, progress, signal) {
                 ...(state?.upload === undefined ? {} : { upload: state.upload }),
             }, (upload) => store.exclusive(() => keepUpload(runtime, local, room.locator, head.id, upload)));
         }
-        catch {
-            answered();
+        catch (error) {
+            runtime.retries.failed('sending', submitting(room.locator), error);
+            heard();
             progress.complete = false;
             if (socket.continuing())
                 progress.reachable = false;
             return 'again';
         }
         if (signal.aborted) {
-            answered();
+            heard();
             return 'done';
         }
         if (result.kind !== 'accepted' || !socket.continuing())
-            answered();
+            heard();
         if (!socket.continuing())
             return 'done';
+        if (result.kind === 'accepted')
+            runtime.retries.succeeded('sending', submitting(room.locator));
         if (result.kind === 'transport-uncertainty') {
+            runtime.retries.uncertain('sending', submitting(room.locator), result);
             progress.complete = false;
             progress.reachable = false;
             return 'again';
         }
         if (result.kind === 'room-not-readable') {
             progress.complete = false;
-            roomUnreadable(runtime, socket.rooms.discovered(result.locator) ?? room);
+            roomUnreadable(runtime, (presence.room(result.locator) ?? room).locator);
             return 'done';
         }
         if (result.kind === 'revoked-authorization') {
@@ -263,81 +209,54 @@ async function submitRoom(runtime, room, local, authorized, progress, signal) {
             return 'done';
         }
         if (result.kind === 'scoped-refusal') {
-            await runtime.scoped(result, room, local);
+            await scoped(runtime, result, room.locator, declared(room));
             progress.complete = false;
             return 'done';
         }
         if (result.kind === 'write-halted') {
-            journal.record(`outcome ${room.locator} ${head.id} write-halted`);
             await store.exclusive(() => mark(runtime, local, room.locator, head, { state: 'waiting' }, lost));
             if (!socket.haltedSince(opensBefore))
                 continue;
             progress.complete = false;
             return 'done';
         }
-        const other = partner === null ? undefined : socket.rooms.discovered(partner);
-        if (result.kind === 'conflicted' ||
-            result.kind === 'rejected' ||
-            result.kind === 'retryable-refusal') {
-            journal.record(`outcome ${room.locator} ${head.id} ${result.kind}` +
-                (result.kind === 'conflicted' && result.roomVersion !== undefined
-                    ? ` ${result.roomVersion}`
-                    : ''));
-            journal.record(`refusal ${result.kind} ${result.code}`);
-        }
+        const other = partner === null ? undefined : presence.room(partner);
         if (result.kind === 'retryable-refusal') {
+            runtime.retries.failed('sending', submitting(room.locator), refusalError(result));
             const reset = result.reset;
             progress.complete = false;
             await store.exclusive(() => mark(runtime, local, room.locator, head, reset === undefined ? { state: 'waiting' } : { state: 'reset', reset }, lost));
             return reset === undefined ? 'again' : { at: Date.parse(reset) };
         }
         if (result.kind === 'conflicted' || result.kind === 'rejected') {
-            const left = leaving(head, result);
             const refreshed = async () => ({
-                there: other === undefined ? null : await advanced(other, local, authorized),
-                here: await advanced(room, local, authorized),
+                there: other === undefined ? null : await advanced(runtime, other, local, authorized),
+                here: await advanced(runtime, room, local, authorized),
             });
             const judged = result.kind === 'conflicted' && other !== undefined ? await refreshed() : null;
             if (judged !== null && (judged.there !== null || judged.here !== null)) {
                 await store.exclusive(() => mark(runtime, local, room.locator, head, { state: 'waiting' }, lost));
                 if (other !== undefined && judged.there !== null) {
-                    await withhold(judged.there, other, local, progress);
+                    await withhold(runtime, judged.there, other, local, progress);
                 }
                 if (judged.here !== null)
-                    await withhold(judged.here, room, local, progress);
+                    await withhold(runtime, judged.here, room, local, progress);
                 return 'done';
             }
-            await store.exclusive(async () => {
-                if (!socket.continuing())
-                    return;
-                const work = await store.work(room.locator);
-                const current = work.replica;
-                if (current === undefined || !current.queue.some((batch) => batch.id === head.id)) {
-                    return;
-                }
-                const confirmedLayer = await sliceAt(store, current.record, 'confirmed', [head]);
-                const held = result.kind === 'conflicted' &&
-                    (await landedWhole(store, room.locator, head, confirmedLayer, result.affected));
-                if (held && partner === null && !landed(head, confirmedLayer)) {
-                    store.landed.hold(room.locator, head.id, Object.fromEntries([...touchedBy([head])].map((path) => [path, confirmedLayer.revisions[path]])));
-                    return;
-                }
-                store.changed(await settle(runtime, local, room.locator, work, current.record, current.queue.filter((batch) => batch.id !== head.id), { leaving: [held ? { ...left, returned: null } : left] }));
-                await unpair(runtime, local);
-                statusShown(runtime);
-            });
+            await answered(runtime, room.locator, head, result);
             const { there, here } = judged ?? (await refreshed());
-            if (other !== undefined && there !== null)
-                await withhold(there, other, local, progress);
+            if (other !== undefined && there !== null) {
+                await withhold(runtime, there, other, local, progress);
+            }
             if (here !== null) {
-                await withhold(here, room, local, progress);
+                await withhold(runtime, here, room, local, progress);
                 return 'done';
             }
             continue;
         }
         const kept = await (partner === null
             ? adopted(runtime, room, local, head, result)
-            : adoptedMove(runtime, room, partner, local, head, result)).finally(answered);
+            : adoptedMove(runtime, room, partner, local, head, result)).finally(heard);
         if (!kept) {
             progress.complete = false;
             return 'done';
@@ -345,14 +264,17 @@ async function submitRoom(runtime, room, local, authorized, progress, signal) {
     }
     return 'done';
 }
+function submitting(locator) {
+    return `submit ${locator}`;
+}
 export function submitLater(runtime, locator) {
     if (runtime.localSaves)
         return;
-    void runtime.recovery.attempt(`submit ${locator}`, (signal) => submitPass(runtime, locator, signal));
+    void runtime.recovery.attempt(submitting(locator), (signal) => submitPass(runtime, locator, signal));
 }
 async function submitPass(runtime, locator, signal) {
-    const { store, socket } = runtime;
-    const room = socket.rooms.discovered(locator);
+    const { store, socket, presence } = runtime;
+    const room = presence.room(locator);
     if (!socket.continuing() || socket.stopping() || room === undefined) {
         return 'done';
     }
@@ -365,7 +287,8 @@ async function submitPass(runtime, locator, signal) {
             return 'done';
         next = await submitRoom(runtime, room, await store.open(), authorization, progress, signal);
     }
-    catch {
+    catch (error) {
+        runtime.retries.failed('sending', submitting(locator), error);
         progress.reachable = false;
         next = 'again';
     }
@@ -374,12 +297,3 @@ async function submitPass(runtime, locator, signal) {
     await rest(runtime, progress);
     return next === 'again' && !socket.isOpen() ? 'done' : next;
 }
-export async function submitAll(runtime) {
-    const { store } = runtime;
-    if (runtime.localSaves)
-        return;
-    for (const locator of await (await store.open()).queued()) {
-        if (!store.fences.has(locator))
-            submitLater(runtime, locator);
-    }
-}

package/dist/act-lanes.d.ts

@@ -0,0 +1,30 @@
+import { type Expected, type Expecting } from './expectation.js';
+export type Ended = 'accepted' | 'refused' | 'unanswered' | 'unsent';
+export type Send<O> = {
+    (name: string, input: unknown, sending: (operation: string) => Promise<O>): Promise<O>;
+    expect(expected: Expected): void;
+};
+export type LaneShown<O> = {
+    readonly busy: boolean;
+    readonly drawn: boolean;
+    readonly ended: O | null;
+};
+export type Lane<O> = {
+    run(steps: (send: Send<O>) => Promise<O>, expected?: Expected): Promise<O>;
+    shown(): LaneShown<O>;
+    subscribe(listener: () => void): () => void;
+    forget(): void;
+};
+export type Acting<O> = {
+    open(): Lane<O>;
+};
+export type ActingRules<O> = {
+    readonly store: Pick<Expecting, 'begin' | 'expect' | 'drop'>;
+    readonly uncertain: O;
+    ending(outcome: O): Ended;
+    acted?(): void;
+    mint?(): string;
+    settles?(operation: string): Promise<boolean>;
+};
+export declare function acting<O>(rules: ActingRules<O>): Acting<O>;
+//# sourceMappingURL=act-lanes.d.ts.map

package/dist/act-lanes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"act-lanes.d.ts","sourceRoot":"","sources":["../src/act-lanes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,KAAK,QAAQ,EAAE,KAAK,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAG/E,MAAM,MAAM,KAAK,GAAG,UAAU,GAAG,SAAS,GAAG,YAAY,GAAG,QAAQ,CAAC;AAErE,MAAM,MAAM,IAAI,CAAC,CAAC,IAAI;IACpB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IACvF,MAAM,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAAC;CAClC,CAAC;AAEF,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI;IACzB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,IAAI,CAAC,CAAC,IAAI;IACpB,GAAG,CAAC,KAAK,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,EAAE,QAAQ,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IAC3E,KAAK,IAAI,SAAS,CAAC,CAAC,CAAC,CAAC;IACtB,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC;IAC5C,MAAM,IAAI,IAAI,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,MAAM,CAAC,CAAC,IAAI;IACtB,IAAI,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI;IAC3B,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC,SAAS,EAAE,OAAO,GAAG,QAAQ,GAAG,MAAM,CAAC,CAAC;IAC7D,QAAQ,CAAC,SAAS,EAAE,CAAC,CAAC;IACtB,MAAM,CAAC,OAAO,EAAE,CAAC,GAAG,KAAK,CAAC;IAC1B,KAAK,CAAC,IAAI,IAAI,CAAC;IACf,IAAI,CAAC,IAAI,MAAM,CAAC;IAChB,OAAO,CAAC,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CAC/C,CAAC;AAUF,wBAAgB,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CA6N1D"}