@agentshouse/mdruntime 0.1.0-ca1eff92bbe73 → 0.1.0-ca4dc698bd0c4

package/dist/read-side.js

@@ -1,7 +1,7 @@
 import { and, BasicIndex, configureIndexDevMode, count, createCollection, createLiveQueryCollection, deepEquals, eq, inArray, or, toArray, } from '@tanstack/db';
-import { ARRAY_INDEX, pointerSegments } from '@agentshouse/mdmodel';
-import { rowsOf } from './observation.js';
+import { ARRAY_INDEX, parse, pointerSegments } from '@agentshouse/mdmodel';
 import { documentKey } from './rows.js';
+import { after, inUnits, ROW_WEIGHT } from './turn.js';
 function every(expressions) {
     const [first, second, ...rest] = expressions;
     return second === undefined ? first : and(first, second, ...rest);
@@ -101,14 +101,11 @@ function filtered(q, rows, plan) {
     }
     return query;
 }
-function named(prefix, names, source) {
-    return Object.fromEntries(names.map((name, index) => [`${prefix}${index}`, source[name]]));
+function bodied(shape) {
+    return shape.sections !== null || shape.preamble || shape.markdown;
 }
 function documents(q, rows, plan, shape) {
     let query = filtered(q, rows, plan);
-    if (shape.sections !== null || shape.preamble || shape.markdown) {
-        query = query.leftJoin({ b: rows }, ({ d, b }) => eq(d.body, b.key));
-    }
     for (const { key, options } of shape.orderBy) {
         query = query.orderBy(({ d }) => keyed(key, d), options);
     }
@@ -117,15 +114,13 @@ function documents(q, rows, plan, shape) {
     }
     if (plan.limit !== null)
         query = query.limit(plan.limit);
-    return query.select(({ d, b }) => ({
+    return query.select(({ d }) => ({
         room: d.room,
         path: d.path,
         type: d.type,
+        binary: d.binary,
         ...(shape.fields === null ? {} : { fields: d.fields }),
-        ...(shape.sections === 'all' ? { sections: b.sections } : {}),
-        ...(Array.isArray(shape.sections) ? named('section', shape.sections, b.sections) : {}),
-        ...(shape.preamble ? { preamble: b.preamble } : {}),
-        ...(shape.markdown ? { markdown: b.markdown } : {}),
+        ...(bodied(shape) ? { text: d.text } : {}),
         ...(shape.backlinks ? { backlinks: toArray(backlinked(q, rows, d, plan.reach)) } : {}),
         ...(shape.change ? { change: d.change } : {}),
     }));
@@ -171,13 +166,22 @@ function built(rows, plan) {
         },
     };
 }
-function present(entries) {
-    return Object.fromEntries(entries.filter(([, value]) => value !== undefined));
-}
-function part(row, prefix, names, whole) {
+function sectionsOf(sections, names) {
     if (names === 'all')
-        return whole;
-    return present(names.map((name, index) => [name, row[`${prefix}${index}`]]));
+        return sections;
+    return Object.fromEntries(names.flatMap((name) => (Object.hasOwn(sections, name) ? [[name, sections[name]]] : [])));
+}
+function bodyOf(row, key, bodies) {
+    const text = row.text;
+    if (text === null)
+        return null;
+    const held = bodies?.get(key);
+    if (held !== undefined && held.text === text)
+        return held.document;
+    const read = parse(text, row.path);
+    const document = read.ok ? read.document : null;
+    bodies?.set(key, { text, document });
+    return document;
 }
 function masked(pointers) {
     const root = { whole: false, members: new Map() };
@@ -228,9 +232,16 @@ function cut(value, mask) {
 function selected(fields, pointers) {
     return (cut(fields, masked(pointers)) ?? {});
 }
-function documentOf(row, shape) {
-    if (row.type === null)
-        return { room: row.room, path: row.path };
+function documentOf(key, row, shape, bodies) {
+    if (row.type === null) {
+        const binary = row.binary;
+        return {
+            room: row.room,
+            path: row.path,
+            ...(binary === null ? {} : { binaryFile: binary }),
+        };
+    }
+    const body = bodied(shape) ? bodyOf(row, key, bodies) : null;
     return {
         room: row.room,
         path: row.path,
@@ -242,13 +253,11 @@ function documentOf(row, shape) {
                     ? row.fields
                     : selected(row.fields, shape.fields),
             }),
-        ...(shape.sections === null
+        ...(shape.sections === null || body === null
             ? {}
-            : {
-                sections: part(row, 'section', shape.sections, row.sections),
-            }),
-        ...(shape.preamble ? { preamble: row.preamble } : {}),
-        ...(shape.markdown ? { markdown: row.markdown } : {}),
+            : { sections: sectionsOf(body.sections, shape.sections) }),
+        ...(shape.preamble && body !== null ? { preamble: body.preamble } : {}),
+        ...(shape.markdown && body !== null ? { markdown: body.content } : {}),
         ...(shape.backlinks
             ? {
                 backlinks: row.backlinks.map(({ path, type, field }) => ({ path, type, field })),
@@ -257,30 +266,40 @@ function documentOf(row, shape) {
         ...(shape.change ? { change: row.change } : {}),
     };
 }
-function keyedOf(plan, entries) {
+function weight(row) {
+    return ROW_WEIGHT + (typeof row?.text === 'string' ? row.text.length : 0);
+}
+function rowsOfPlan(plan, entries, bodies, each = (row) => row) {
     const shape = plan.shape;
     if (shape.kind === 'documents') {
-        return {
-            result: structuredClone({ documents: entries.map(([, row]) => documentOf(row, shape)) }),
-            keys: entries.map(([key]) => key),
-        };
+        const documents = [];
+        return after(inUnits(entries, ([key, row]) => {
+            documents.push(each(documentOf(key, row, shape, bodies)));
+            return weight(row);
+        }), () => ({ rows: { documents }, keys: entries.map(([key]) => key) }));
     }
     const bounded = shape.orderBy.length === 0 && plan.limit !== null ? entries.slice(0, plan.limit) : entries;
-    return {
-        result: structuredClone({
-            groups: bounded.map(([, row]) => ({
-                key: shape.groupBy.map((_, index) => row[`key${index}`]),
-                count: row.count,
-            })),
-        }),
-        keys: bounded.map(([key]) => key),
-    };
+    const groups = [];
+    return after(inUnits(bounded, ([, row]) => {
+        groups.push(each({
+            key: shape.groupBy.map((_, index) => row[`key${index}`]),
+            count: row.count,
+        }));
+        return ROW_WEIGHT;
+    }), () => ({ rows: { groups }, keys: bounded.map(([key]) => key) }));
 }
 export function reconciled(previous, next) {
-    const before = rowsOf(previous.result);
-    const held = new Map(previous.keys.map((key, index) => [key, before[index]]));
+    const before = previous.result;
+    const after = next.result;
+    if ('pending' in before || 'pending' in after) {
+        if (deepEquals(before, after))
+            return null;
+        return { keyed: next, message: next };
+    }
+    const earlier = 'groups' in before ? before.groups : before.documents;
+    const held = new Map(previous.keys.map((key, index) => [key, earlier[index]]));
     const changed = [];
-    const rows = rowsOf(next.result).map((row, index) => {
+    const rows = ('groups' in after ? after.groups : after.documents).map((row, index) => {
         const key = next.keys[index];
         const kept = held.get(key);
         if (kept !== undefined && deepEquals(kept, row))
@@ -289,22 +308,37 @@ export function reconciled(previous, next) {
         return row;
     });
     const present = new Set(next.keys);
-    const survivors = previous.keys.filter((key) => present.has(key));
     const removed = previous.keys.filter((key) => !present.has(key));
-    const moved = survivors.length !== next.keys.length ||
-        survivors.some((key, index) => key !== next.keys[index]);
-    if (changed.length === 0 && removed.length === 0 && !moved)
+    const moved = reordered(previous.keys, next.keys, present);
+    const covered = !deepEquals(before.coverage, after.coverage);
+    if (changed.length === 0 && removed.length === 0 && !moved && !covered)
         return null;
     return {
         keyed: {
-            result: 'groups' in next.result
-                ? { groups: rows }
-                : { documents: rows },
+            result: 'groups' in after
+                ? { groups: rows, coverage: after.coverage }
+                : { documents: rows, coverage: after.coverage },
             keys: next.keys,
         },
-        change: { changed, removed, order: moved ? next.keys : null },
+        message: {
+            changed,
+            removed,
+            order: moved ? next.keys : null,
+            ...(covered ? { coverage: after.coverage } : {}),
+        },
     };
 }
+function reordered(previous, next, present) {
+    let at = 0;
+    for (const key of previous) {
+        if (!present.has(key))
+            continue;
+        if (next[at] !== key)
+            return true;
+        at += 1;
+    }
+    return at !== next.length;
+}
 export function createReadSide() {
     configureIndexDevMode({ enabled: false });
     let sync;
@@ -324,23 +358,139 @@ export function createReadSide() {
     });
     const shared = new Map();
     function searched(row) {
-        const body = rows.get(row.body);
+        const read = row.text === null ? null : parse(row.text, row.path);
+        if (read === null || !read.ok)
+            return null;
         return {
             room: row.room,
             path: row.path,
             type: row.type,
             fields: row.fields,
-            preamble: body.preamble,
-            sections: body.sections,
+            preamble: read.document.preamble,
+            sections: read.document.sections,
         };
     }
-    function publish(entry) {
-        const next = reconciled(entry.result, keyedOf(entry.plan, [...entry.built.live.entries()]));
-        if (next === null)
+    function kept(entry, key, row) {
+        const held = entry.rows.get(key);
+        if (held !== undefined && deepEquals(held, row))
             return;
-        entry.result = next.keyed;
-        for (const listener of entry.listeners)
-            listener(next.change);
+        entry.rows.set(key, row);
+    }
+    function rebuilt(entry) {
+        return after(rowsOfPlan(entry.plan, [...entry.built.live.entries()], entry.bodies), ({ rows: found, keys }) => {
+            const present = new Set(keys);
+            for (const key of [...entry.rows.keys()])
+                if (!present.has(key))
+                    entry.rows.delete(key);
+            for (const key of [...entry.bodies.keys()]) {
+                if (!present.has(key))
+                    entry.bodies.delete(key);
+            }
+            keys.forEach((key, index) => kept(entry, key, rowAt(found, index)));
+            return keys;
+        });
+    }
+    function refreshed(entry, dirty) {
+        const shape = entry.plan.shape;
+        const keys = [...entry.built.live.keys()];
+        const named = new Set([...dirty, ...keys.filter((key) => !entry.rows.has(key))]);
+        const values = [...named].map((key) => [key, entry.built.live.get(key)]);
+        const done = inUnits(values, ([key, value]) => {
+            if (value !== undefined)
+                kept(entry, key, documentOf(key, value, shape, entry.bodies));
+            else {
+                entry.rows.delete(key);
+                entry.bodies.delete(key);
+            }
+            return weight(value);
+        });
+        return after(done, () => keys);
+    }
+    function current(entry, keys, coverage) {
+        const found = keys.map((key) => entry.rows.get(key));
+        return {
+            result: entry.plan.shape.kind === 'groups'
+                ? { groups: found, coverage }
+                : { documents: found, coverage },
+            keys,
+        };
+    }
+    function delivered(entry, next) {
+        const previous = entry.result;
+        entry.result = next;
+        const message = previous === undefined ? null : changedFrom(previous, next);
+        if (message !== null)
+            for (const listener of entry.ready)
+                listener(message);
+        for (const listener of entry.fresh) {
+            entry.ready.add(listener);
+            listener(next);
+        }
+        entry.fresh.clear();
+    }
+    function run(entry) {
+        while (entry.listeners.size > 0 &&
+            (entry.whole || entry.dirty.size > 0 || entry.stale || entry.fresh.size > 0)) {
+            entry.stale = false;
+            const cover = entry.cover();
+            if ('pending' in cover) {
+                entry.whole = true;
+                entry.dirty.clear();
+                entry.rows.clear();
+                entry.bodies.clear();
+                delivered(entry, { result: cover, keys: [] });
+                break;
+            }
+            const whole = entry.whole ||
+                entry.plan.shape.kind === 'groups' ||
+                entry.result === undefined ||
+                'pending' in entry.result.result;
+            const dirty = entry.dirty;
+            entry.dirty = new Set();
+            entry.whole = false;
+            const keys = whole ? rebuilt(entry) : refreshed(entry, dirty);
+            if (keys instanceof Promise) {
+                void keys
+                    .then((found) => {
+                    if (entry.listeners.size > 0)
+                        delivered(entry, current(entry, found, cover.coverage));
+                    run(entry);
+                })
+                    .catch(() => {
+                    entry.running = false;
+                });
+                return;
+            }
+            delivered(entry, current(entry, keys, cover.coverage));
+        }
+        entry.running = false;
+    }
+    function wake(entry) {
+        if (entry.subscription === null || entry.running)
+            return;
+        entry.running = true;
+        try {
+            run(entry);
+        }
+        catch (error) {
+            entry.running = false;
+            throw error;
+        }
+    }
+    function recover() {
+        for (const entry of shared.values()) {
+            if (entry.result === undefined || entry.subscription === null)
+                continue;
+            const cover = entry.cover();
+            const before = entry.result.result;
+            const held = 'pending' in cover
+                ? deepEquals(before, cover)
+                : 'coverage' in before && deepEquals(before.coverage, cover.coverage);
+            if (held)
+                continue;
+            entry.stale = true;
+            wake(entry);
+        }
     }
     return {
         apply(set) {
@@ -351,38 +501,52 @@ export function createReadSide() {
                 for (const row of change.after)
                     next.set(row.key, row);
             }
-            if (next.size === 0)
-                return;
-            sync.begin();
-            for (const [key, row] of next) {
-                if (row === null) {
-                    if (rows.has(key))
-                        sync.write({ type: 'delete', key });
-                    continue;
+            if (next.size > 0) {
+                sync.begin();
+                for (const [key, row] of next) {
+                    if (row === null) {
+                        if (rows.has(key))
+                            sync.write({ type: 'delete', key });
+                        continue;
+                    }
+                    sync.write({ type: rows.has(key) ? 'update' : 'insert', value: row });
                 }
-                sync.write({ type: rows.has(key) ? 'update' : 'insert', value: row });
+                sync.commit();
             }
-            sync.commit();
+            recover();
         },
-        async query(plan) {
+        recover,
+        async query(plan, at) {
             const { live: collection, dispose } = built(rows, plan);
             try {
                 await collection.toArrayWhenReady();
-                return keyedOf(plan, [...collection.entries()]).result;
+                const entries = [...collection.entries()];
+                const held = at();
+                const found = await rowsOfPlan(plan, entries, null, structuredClone);
+                return { rows: found.rows, at: held };
             }
             finally {
                 dispose();
             }
         },
-        watch(plan, identity, deliver) {
+        watch(plan, identity, cover, deliverTo) {
             let entry = shared.get(identity);
             if (entry === undefined) {
                 const created = {
                     plan,
                     built: built(rows, plan),
+                    cover,
                     result: undefined,
+                    rows: new Map(),
+                    bodies: new Map(),
                     listeners: new Set(),
+                    fresh: new Set(),
+                    ready: new Set(),
                     subscription: null,
+                    whole: true,
+                    dirty: new Set(),
+                    stale: false,
+                    running: false,
                 };
                 created.built.live.on('status:change', ({ status }) => {
                     if (status === 'cleaned-up' && created.listeners.size === 0)
@@ -392,29 +556,40 @@ export function createReadSide() {
                 entry = created;
             }
             const observed = entry;
-            observed.listeners.add(deliver);
+            observed.listeners.add(deliverTo);
             observed.built.live.onFirstReady(() => {
-                if (!observed.listeners.has(deliver))
+                if (!observed.listeners.has(deliverTo))
                     return;
+                observed.fresh.add(deliverTo);
                 if (observed.subscription === null) {
-                    observed.result = keyedOf(observed.plan, [...observed.built.live.entries()]);
-                    observed.subscription = observed.built.live.subscribeChanges(() => {
-                        publish(observed);
+                    observed.whole = true;
+                    observed.subscription = observed.built.live.subscribeChanges((changes) => {
+                        if (observed.plan.shape.kind === 'groups')
+                            observed.whole = true;
+                        else
+                            for (const { key } of changes)
+                                observed.dirty.add(key);
+                        wake(observed);
                     }, { includeInitialState: false });
                 }
-                deliver(observed.result);
+                wake(observed);
             });
             return () => {
-                if (!observed.listeners.delete(deliver) || observed.listeners.size > 0)
+                observed.fresh.delete(deliverTo);
+                observed.ready.delete(deliverTo);
+                if (!observed.listeners.delete(deliverTo) || observed.listeners.size > 0)
                     return;
                 observed.subscription?.unsubscribe();
                 observed.subscription = null;
+                observed.result = undefined;
+                observed.rows.clear();
+                observed.bodies.clear();
+                observed.dirty.clear();
+                observed.whole = true;
             };
         },
-        documents() {
-            return rows.toArray
-                .filter((row) => row.kind === 'document' && row.type !== null)
-                .map(searched);
+        room(room) {
+            return rows.toArray.flatMap((row) => row.kind !== 'document' || row.type === null || row.room !== room ? [] : [row.path]);
         },
         document(room, path) {
             const row = rows.get(documentKey(room, path));
@@ -423,6 +598,8 @@ export function createReadSide() {
         close() {
             for (const entry of shared.values()) {
                 entry.listeners.clear();
+                entry.fresh.clear();
+                entry.ready.clear();
                 entry.subscription?.unsubscribe();
                 entry.built.dispose();
             }
@@ -431,3 +608,32 @@ export function createReadSide() {
         },
     };
 }
+function changedFrom(previous, next) {
+    const before = previous.result;
+    const after = next.result;
+    if ('pending' in before || 'pending' in after)
+        return deepEquals(before, after) ? null : next;
+    const earlier = 'groups' in before ? before.groups : before.documents;
+    const held = new Map(previous.keys.map((key, index) => [key, earlier[index]]));
+    const later = 'groups' in after ? after.groups : after.documents;
+    const changed = [];
+    next.keys.forEach((key, index) => {
+        if (held.get(key) !== later[index])
+            changed.push([key, later[index]]);
+    });
+    const present = new Set(next.keys);
+    const removed = previous.keys.filter((key) => !present.has(key));
+    const moved = reordered(previous.keys, next.keys, present);
+    const covered = !deepEquals(before.coverage, after.coverage);
+    if (changed.length === 0 && removed.length === 0 && !moved && !covered)
+        return null;
+    return {
+        changed,
+        removed,
+        order: moved ? next.keys : null,
+        ...(covered ? { coverage: after.coverage } : {}),
+    };
+}
+function rowAt(rows, index) {
+    return 'groups' in rows ? rows.groups[index] : rows.documents[index];
+}

package/dist/readiness.d.ts

@@ -0,0 +1,53 @@
+import type { Open } from './open.js';
+export type CodeAvailability = Open<'stored' | 'absent'>;
+export type RoomPreparation = Open<'complete' | 'acquiring' | 'preparing' | 'indexing' | 'refused' | 'unadmitted'>;
+export type RoomCoverage = {
+    readonly room: string;
+    readonly state: RoomPreparation;
+};
+export type ConversationCoverage = Open<'complete' | 'acquiring' | 'indexing' | 'undeclared'>;
+export type SearchObligation = Open<'required' | 'unused'>;
+export type TargetCoverage = {
+    readonly complete: boolean;
+    readonly listed: boolean;
+    readonly rooms: readonly RoomCoverage[];
+    readonly conversations: ConversationCoverage;
+    readonly search: SearchObligation;
+};
+export type Persistence = Open<'granted' | 'denied' | 'unavailable'>;
+export type Durability = Open<'persistent' | 'best-effort'>;
+export type ConnectionAvailability = Open<'connected' | 'connecting' | 'unreachable'>;
+export type HouseOutcome = Open<'open' | 'write-halted' | 'refused'>;
+export type CapacityCause = {
+    readonly cause: Open<'insufficient-space' | 'quota-exceeded'>;
+    readonly needed: number | null;
+    readonly available: number | null;
+};
+export type RefusedRoom = {
+    readonly room: string;
+    readonly file: string;
+    readonly rule: string;
+    readonly location: string | null;
+};
+export type ReadinessStatus = Open<'preparing' | 'paused' | 'refused' | 'ready' | 'lost'>;
+export type Readiness = {
+    readonly status: ReadinessStatus;
+    readonly ready: boolean;
+    readonly usable: boolean;
+    readonly code: CodeAvailability;
+    readonly coverage: TargetCoverage;
+    readonly durability: Durability;
+    readonly persistence: Persistence;
+    readonly connection: ConnectionAvailability;
+    readonly house: HouseOutcome;
+    readonly capacity: CapacityCause | null;
+    readonly refused: readonly RefusedRoom[];
+    readonly lost: boolean;
+};
+export type ReadinessFacts = Omit<Readiness, 'status' | 'ready' | 'usable' | 'durability' | 'coverage'> & {
+    readonly coverage: Omit<TargetCoverage, 'complete'>;
+    readonly established: boolean;
+};
+export declare const SETTLED_ROOMS: ReadonlySet<string>;
+export declare function readinessOf(facts: ReadinessFacts): Readiness;
+//# sourceMappingURL=readiness.d.ts.map

package/dist/readiness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"readiness.d.ts","sourceRoot":"","sources":["../src/readiness.ts"],"names":[],"mappings":"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"}

package/dist/readiness.js

@@ -0,0 +1,33 @@
+const COMPLETE_ROOMS = new Set(['complete', 'unadmitted']);
+export const SETTLED_ROOMS = new Set([...COMPLETE_ROOMS, 'refused']);
+export function readinessOf(facts) {
+    const { established, coverage: held, ...reported } = facts;
+    const settledConversations = held.conversations === 'complete' || held.conversations === 'undeclared';
+    const complete = held.listed &&
+        settledConversations &&
+        held.rooms.every((room) => COMPLETE_ROOMS.has(room.state));
+    const settled = held.listed &&
+        settledConversations &&
+        held.rooms.every((room) => SETTLED_ROOMS.has(room.state));
+    const coverage = { ...held, complete };
+    const stored = facts.code === 'stored';
+    const ready = stored && complete;
+    const usable = stored && (ready || established);
+    const status = ready
+        ? 'ready'
+        : facts.capacity !== null
+            ? 'paused'
+            : facts.lost && !established
+                ? 'lost'
+                : settled && !complete
+                    ? 'refused'
+                    : 'preparing';
+    return {
+        ...reported,
+        coverage,
+        status,
+        ready,
+        usable,
+        durability: facts.persistence === 'granted' ? 'persistent' : 'best-effort',
+    };
+}

package/dist/recovery.d.ts

@@ -0,0 +1,25 @@
+export type Attempted = 'done' | 'again' | {
+    readonly at: number;
+};
+export type Attempt = (signal: AbortSignal) => Promise<Attempted>;
+export type AttemptOptions = {
+    readonly at?: number;
+    readonly again?: boolean;
+};
+export type RecoveryOptions = {
+    readonly firstMs?: number;
+    readonly ceilingMs?: number;
+    readonly attempts?: number;
+    readonly inFlight?: number;
+};
+export type Recovery = {
+    attempt(intent: string, run: Attempt, options?: AttemptOptions): Promise<boolean>;
+    pending(intent: string): boolean;
+    resume(): void;
+    cancel(intent: string): void;
+    scope(inFlight?: number): Recovery;
+    retire(): Promise<void>;
+};
+export declare function retryDelay(tries: number, firstMs?: number, ceilingMs?: number): number;
+export declare function createRecovery(options?: RecoveryOptions): Recovery;
+//# sourceMappingURL=recovery.d.ts.map

package/dist/recovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recovery.d.ts","sourceRoot":"","sources":["../src/recovery.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,OAAO,GAAG;IAAE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC;AAEnE,MAAM,MAAM,OAAO,GAAG,CAAC,MAAM,EAAE,WAAW,KAAK,OAAO,CAAC,SAAS,CAAC,CAAC;AAElE,MAAM,MAAM,cAAc,GAAG;IAAE,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC;AAEhF,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG;IACrB,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAClF,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC;IACjC,MAAM,IAAI,IAAI,CAAC;IACf,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,KAAK,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,QAAQ,CAAC;IACnC,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACzB,CAAC;AAsBF,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,SAAW,EAAE,SAAS,SAAa,GAAG,MAAM,CAG5F;AAuKD,wBAAgB,cAAc,CAAC,OAAO,GAAE,eAAoB,GAAG,QAAQ,CAStE"}