@agentshouse/mdruntime 0.1.0-caee7332d2235 → 0.1.0-caf080a9a9c60

package/dist/replica.js

@@ -1,226 +1,219 @@
 import { equalValue, parse } from '@agentshouse/mdmodel';
 import { immutable, landing } from './change.js';
-import { changedCleanly, collecting, unreadable, validateCollection, } from './collection.js';
-import { acceptedBinaries, overlayChanged, overlaying, sameText, } from './overlay.js';
-import { providerRewritten } from './save.js';
-import { drafted, patched, settled, sharing } from './shared.js';
-import { finished, stepped } from './turn.js';
-export function compositionOf(record) {
+import { collectionOf, definitionsAt } from './collection.js';
+import { storedModel } from './model.js';
+import { acceptedBinaries, overlaying } from './overlay.js';
+import { writtenFacts } from './rows.js';
+import { effectiveIn, rewriting } from './save.js';
+import { guarding } from './shared.js';
+import { ROW_WEIGHT } from './turn.js';
+export function compositionOf(model, typedSelection, builtIn, typedPaths) {
     return {
-        model: record.model,
-        selection: record.typedSelection === null
-            ? null
-            : { roots: record.typedSelection.roots, model: record.selectionModel },
+        model,
+        selection: typedSelection === null ? null : { roots: typedSelection.roots, model: builtIn },
+        typedPaths,
     };
 }
-function* holding(record) {
-    const documents = yield* sharing(record.documents);
-    const binaries = yield* sharing(record.binaries);
-    const revisions = yield* sharing(record.revisions);
-    const fileIds = yield* sharing(record.fileIds);
-    const changes = yield* sharing(record.changes);
-    const written = yield* sharing(record.written);
-    return documents === record.documents &&
-        binaries === record.binaries &&
-        revisions === record.revisions &&
-        fileIds === record.fileIds &&
-        changes === record.changes &&
-        written === record.written
-        ? record
-        : { ...record, documents, binaries, revisions, fileIds, changes, written };
+export function storedRecord(record) {
+    const { key: _key, ...stored } = record;
+    return JSON.stringify({ ...stored, model: storedModel(stored.model) });
 }
-export function confirmedOf(record, previous) {
-    return finished(confirming(record, previous));
+const PROBES = new Set([
+    'then',
+    'toJSON',
+    'constructor',
+    'valueOf',
+    'toString',
+]);
+class UnreadPath extends Error {
+    constructor(path) {
+        super(`the replica slice holds no row for ${path}`);
+    }
 }
-function* confirming(record, previous) {
-    const kept = yield* holding(record);
-    return {
-        record: kept,
-        collection: yield* collecting(kept.documents, compositionOf(kept), previous?.collection),
+function strict(values, held) {
+    const guard = (property) => {
+        if (typeof property === 'string' && !held.has(property) && !PROBES.has(property)) {
+            throw new UnreadPath(property);
+        }
     };
+    return guarding(values, {
+        get(target, property, receiver) {
+            guard(property);
+            return Reflect.get(target, property, receiver);
+        },
+        has(target, property) {
+            guard(property);
+            return Reflect.has(target, property);
+        },
+        getOwnPropertyDescriptor(target, property) {
+            guard(property);
+            return Reflect.getOwnPropertyDescriptor(target, property);
+        },
+    });
 }
-export function sameMembership(record, other) {
-    return (JSON.stringify(record.typedSelection?.roots ?? null) ===
-        JSON.stringify(other.typedSelection?.roots ?? null));
+export function* slicing(entries, paths) {
+    const held = new Set(paths);
+    for (const entry of entries)
+        held.add(entry.path);
+    const documents = {};
+    const binaries = {};
+    const revisions = {};
+    const fileIds = {};
+    const created = {};
+    const changes = {};
+    const written = {};
+    const facts = {};
+    for (const entry of entries) {
+        if (entry.facts !== null)
+            facts[entry.path] = entry.facts;
+        if (entry.binary !== null)
+            binaries[entry.path] = entry.binary;
+        else if (entry.content !== null)
+            documents[entry.path] = entry.content;
+        if (entry.revision !== null)
+            revisions[entry.path] = entry.revision;
+        if (entry.fileId !== null)
+            fileIds[entry.path] = entry.fileId;
+        if (entry.created !== null)
+            created[entry.path] = entry.created;
+        if (entry.change !== null)
+            changes[entry.path] = entry.change;
+        if (entry.written !== null)
+            written[entry.path] = entry.written;
+        yield ROW_WEIGHT;
+    }
+    return {
+        documents: strict(documents, held),
+        binaries: strict(binaries, held),
+        revisions: strict(revisions, held),
+        fileIds: strict(fileIds, held),
+        created: strict(created, held),
+        changes: strict(changes, held),
+        written: strict(written, held),
+        facts: strict(facts, held),
+        held,
+    };
 }
-function* cleanly(record, previous) {
-    if (previous === undefined)
-        return false;
-    const before = previous.record;
-    return yield* changedCleanly({ text: record.documents, binaries: record.binaries }, { text: before.documents, binaries: before.binaries, composition: compositionOf(before) }, compositionOf(record));
+export function entryAt(layer, path) {
+    const content = layer.documents[path];
+    const binary = layer.binaries[path];
+    if (content === undefined && binary === undefined)
+        return null;
+    return {
+        path,
+        content: content ?? null,
+        binary: binary ?? null,
+        revision: layer.revisions[path] ?? null,
+        fileId: layer.fileIds[path] ?? null,
+        created: layer.created[path] ?? null,
+        change: layer.changes[path] ?? null,
+        written: layer.written?.[path] ?? null,
+    };
 }
-function* staging(staged, previous) {
-    const record = yield* holding(staged);
-    const textChanged = previous === undefined || !(yield* sameText(record, previous.record));
-    const modeled = record.model.status !== 'unavailable' || record.selectionModel.status !== 'unavailable';
-    if (modeled &&
-        (textChanged ||
-            record.model !== previous?.record.model ||
-            record.selectionModel !== previous?.record.selectionModel) &&
-        !(yield* cleanly(record, previous))) {
-        const verdict = yield* validateCollection(record.documents, Object.keys(record.binaries), compositionOf(record));
-        if (verdict.verdict === 'refuse' && verdict.rule !== 'model-unavailable') {
-            return { kind: 'refused', refusal: verdict };
-        }
-        if (verdict.verdict === 'refuse') {
-            const refused = yield* unreadable(record.documents, previous?.record.documents);
-            if (refused !== null)
-                return refused;
+export function* slicingWith(slice, set, removed) {
+    const entries = new Map();
+    for (const path of slice.held) {
+        const entry = entryAt(slice, path);
+        if (entry !== null) {
+            entries.set(path, { ...entry, type: null, facts: slice.facts[path] ?? null });
         }
+        yield ROW_WEIGHT;
     }
-    else if (textChanged) {
-        const refused = yield* unreadable(record.documents, previous?.record.documents);
-        if (refused !== null)
-            return refused;
-    }
-    return { kind: 'staged', confirmed: yield* confirming(record, previous) };
+    for (const path of removed)
+        entries.delete(path);
+    for (const entry of set)
+        entries.set(entry.path, { ...entry, type: null });
+    return yield* slicing([...entries.values()], [...slice.held, ...set.map(({ path }) => path), ...removed]);
 }
-export function readStaged(staged, previous) {
-    return stepped(staging(staged, previous));
+function changePaths(change) {
+    return change.kind === 'move' ? [change.path, change.to] : [change.path];
 }
-function* reclassifying(record, previous) {
-    const verdict = yield* validateCollection(record.documents, Object.keys(record.binaries), compositionOf(record));
-    if (verdict.verdict !== 'refuse')
-        return { kind: 'staged', confirmed: yield* confirming(record, previous) };
-    return verdict.rule === 'model-unavailable'
-        ? { kind: 'deferred' }
-        : { kind: 'refused', refusal: verdict };
-}
-export function readReclassified(record, previous) {
-    return stepped(reclassifying(record, previous));
-}
-function returnedBinaries(held, submitted, accepted) {
-    const binaries = drafted(held);
-    for (const change of submitted.changes) {
-        if (change.kind !== 'move')
-            continue;
-        const moved = binaries[change.path];
-        if (moved === undefined || accepted.revisions[change.to] === undefined)
-            continue;
-        binaries[change.to] = moved;
-        delete binaries[change.path];
-    }
-    Object.assign(binaries, acceptedBinaries(accepted.binaryFiles ?? {}));
-    for (const path of accepted.removals)
-        delete binaries[path];
-    return settled(binaries);
-}
-export function applyReturned(confirmed, submitted, accepted, roomVersion, writtenAt) {
-    const { documents, revisions, fileIds, changes, removals } = accepted;
-    const nextDocuments = drafted(confirmed.record.documents);
-    const nextRevisions = drafted(confirmed.record.revisions);
-    const nextFileIds = drafted(confirmed.record.fileIds);
-    const nextChanges = drafted(confirmed.record.changes);
-    const nextWritten = drafted(confirmed.record.written);
-    Object.assign(nextDocuments, documents);
-    Object.assign(nextRevisions, revisions);
-    for (const path of Object.keys({ ...documents, ...revisions }))
-        delete nextFileIds[path];
-    Object.assign(nextFileIds, fileIds);
-    for (const path of Object.keys(documents))
-        nextWritten[path] = writtenAt;
-    for (const [path, revision] of Object.entries(revisions)) {
-        if (confirmed.record.revisions[path] !== revision)
-            delete nextChanges[path];
-    }
-    Object.assign(nextChanges, changes);
-    for (const path of removals) {
-        delete nextDocuments[path];
-        delete nextRevisions[path];
-        delete nextFileIds[path];
-        delete nextChanges[path];
-        delete nextWritten[path];
+export function touchedBy(queue) {
+    const paths = new Set();
+    for (const batch of queue) {
+        for (const change of batch.changes)
+            for (const path of changePaths(change))
+                paths.add(path);
+        for (const precondition of batch.preconditions)
+            paths.add(precondition.path);
+        for (const move of batch.between?.moves ?? [])
+            paths.add(move.path);
     }
-    return readStaged({
-        ...confirmed.record,
-        roomVersion,
-        documents: settled(nextDocuments),
-        revisions: settled(nextRevisions),
-        fileIds: settled(nextFileIds),
-        changes: settled(nextChanges),
-        written: settled(nextWritten),
-        binaries: returnedBinaries(confirmed.record.binaries, submitted, accepted),
-    }, confirmed);
+    return paths;
 }
-function* predicting(confirmed, batches, previous) {
-    const composition = compositionOf(confirmed.record);
-    let layer = confirmed.record;
-    const replay = [];
-    const prior = new Map(previous?.replay.map((step) => [step.id, step]) ?? []);
-    for (const batch of batches) {
-        const before = layer;
-        const old = prior.get(batch.id);
-        const hasMove = batch.changes.some((change) => change.kind === 'move');
-        const reuseRewrite = old?.collection !== undefined &&
-            (yield* sameText(before, old.before)) &&
-            old.collection.composition.model === composition.model &&
-            old.collection.composition.selection?.model === composition.selection?.model &&
-            JSON.stringify(old.collection.composition.selection?.roots) ===
-                JSON.stringify(composition.selection?.roots);
-        const collection = hasMove
-            ? reuseRewrite
-                ? old.collection
-                : yield* collecting(before.documents, composition, old?.collection ?? confirmed.collection)
-            : undefined;
-        const effective = collection === undefined
-            ? batch
-            : reuseRewrite
-                ? old.effective
-                : yield* providerRewritten(batch, { ...before, collection });
-        layer =
-            old === undefined
-                ? yield* overlaying(before, [effective])
-                : yield* overlayChanged(before, effective, old.before, old.effective, old.after);
-        replay.push({
-            id: batch.id,
-            before,
-            after: layer,
-            effective,
-            ...(collection === undefined ? {} : { collection }),
-        });
+export function movedBy(queue, locator) {
+    const paths = new Set();
+    for (const batch of queue) {
+        if (!rewriting(batch, locator))
+            continue;
+        for (const change of batch.changes)
+            if (change.kind === 'move')
+                paths.add(change.path);
+        if (batch.between?.source.room === locator) {
+            for (const move of batch.between.moves)
+                paths.add(move.path);
+        }
     }
-    return { layer, replay };
+    return paths;
 }
-export function* replicating(confirmed, queue, previous) {
-    const batches = Object.freeze(queue.map(immutable));
-    if (batches.length === 0) {
-        return {
-            confirmed,
-            queue: batches,
-            visible: {
-                documents: confirmed.record.documents,
-                binaries: confirmed.record.binaries,
-                revisions: confirmed.record.revisions,
-                fileIds: confirmed.record.fileIds,
-                changes: confirmed.record.changes,
-                collection: confirmed.collection,
-            },
-            replay: [],
-        };
+export function* replaying(confirmed, queue, locator, composition) {
+    let layer = confirmed;
+    const touched = new Set();
+    for (const batch of queue) {
+        const effective = rewriting(batch, locator)
+            ? yield* effectiveIn(batch, locator, {
+                ...layer,
+                collection: collectionOf(layer.documents, composition),
+            })
+            : batch;
+        for (const change of effective.changes)
+            for (const path of changePaths(change))
+                touched.add(path);
+        layer = yield* overlaying(layer, [effective], composition);
+        yield ROW_WEIGHT;
     }
-    const { layer, replay } = yield* predicting(confirmed, batches, previous);
     return {
-        confirmed,
-        queue: batches,
-        replay,
-        visible: {
-            ...layer,
-            collection: yield* collecting(layer.documents, compositionOf(confirmed.record), previous?.visible.collection ?? confirmed.collection),
-        },
+        visible: { ...layer, collection: collectionOf(layer.documents, composition) },
+        touched,
     };
 }
-export function replicaOf(confirmed, queue, previous) {
-    return finished(replicating(confirmed, queue, previous));
+export function* overlayOf(visible, touched) {
+    const rows = [];
+    for (const path of touched) {
+        const entry = entryAt(visible, path);
+        yield ROW_WEIGHT + (entry?.content?.length ?? 0);
+        const text = entry?.binary === null ? entry.content : null;
+        rows.push(entry === null
+            ? {
+                path,
+                present: false,
+                content: null,
+                binary: null,
+                revision: null,
+                fileId: null,
+                created: null,
+                change: null,
+                written: null,
+                facts: null,
+            }
+            : {
+                ...entry,
+                written: null,
+                present: true,
+                facts: text === null ? null : writtenFacts(path, text, visible.collection.composition),
+            });
+    }
+    return rows;
 }
 function present(layer, path) {
     return layer.documents[path] !== undefined || layer.binaries[path] !== undefined;
 }
-function holds(layer, preconditions) {
+export function holds(layer, preconditions, composition) {
     const parsed = new Map();
     const documentAt = (path) => {
         if (!parsed.has(path)) {
             const text = layer.documents[path];
-            const opened = text === undefined ? null : parse(text, path);
+            const opened = text === undefined ? null : parse(text, path, definitionsAt(composition, path));
             parsed.set(path, opened?.ok === true ? opened.document : null);
         }
         return parsed.get(path) ?? null;
@@ -280,15 +273,19 @@ function effects(change) {
             { kind: 'present', path: change.to },
         ];
     }
-    if (change.kind === 'binary')
+    if (change.kind === 'arrival')
         return [{ kind: 'present', path }];
     return [{ kind: 'absent', path }];
 }
-export function landed(batch, confirmed, current = {}) {
-    const layer = {
-        ...confirmed.record,
-        documents: patched(confirmed.record.documents, Object.entries(current)),
-    };
+export function landed(batch, confirmed, composition, current = {}) {
+    const documents = new Proxy(confirmed.documents, {
+        get(target, property, receiver) {
+            if (typeof property === 'string' && Object.hasOwn(current, property))
+                return current[property];
+            return Reflect.get(target, property, receiver);
+        },
+    });
+    const layer = { ...confirmed, documents };
     return batch.changes.every((change, index) => {
         if (change.kind === 'replace' || (change.kind === 'create' && 'content' in change)) {
             const at = landing(batch.changes, index, change.path);
@@ -300,9 +297,9 @@ export function landed(batch, confirmed, current = {}) {
         }
         return effects(change).every((effect) => {
             if (effect.kind === 'absent')
-                return holds(layer, [effect]);
+                return holds(layer, [effect], composition);
             const at = landing(batch.changes, index, effect.path);
-            return at === null || holds(layer, [{ ...effect, path: at }]);
+            return at === null || holds(layer, [{ ...effect, path: at }], composition);
         });
     });
 }
@@ -320,26 +317,25 @@ function founded(batch, layer) {
     });
     return changed ? immutable({ ...batch, preconditions }) : batch;
 }
-export function* standing(confirmed, queue, withdrawable, local) {
+export function* standing(confirmed, queue, withdrawable, local, locator, composition) {
     if (!queue.some(withdrawable))
         return { withdrawn: [], kept: queue };
-    const composition = compositionOf(confirmed.record);
-    let layer = confirmed.record;
+    let layer = confirmed;
     const withdrawn = [];
     const kept = [];
     for (const batch of queue) {
-        if (withdrawable(batch) && !holds(layer, batch.preconditions)) {
+        if (withdrawable(batch) && !holds(layer, batch.preconditions, composition)) {
             withdrawn.push(batch);
             continue;
         }
-        const effective = batch.changes.some((change) => change.kind === 'move')
-            ? yield* providerRewritten(batch, {
+        const effective = rewriting(batch, locator)
+            ? yield* effectiveIn(batch, locator, {
                 ...layer,
-                collection: yield* collecting(layer.documents, composition),
+                collection: collectionOf(layer.documents, composition),
             })
             : batch;
         let unapplied = false;
-        const next = yield* overlaying(layer, [effective], () => {
+        const next = yield* overlaying(layer, [effective], composition, () => {
             unapplied = true;
         });
         if (local && unapplied) {
@@ -351,3 +347,118 @@ export function* standing(confirmed, queue, withdrawable, local) {
     }
     return { withdrawn, kept };
 }
+export function returnedPaths(submitted, accepted) {
+    const paths = new Set([
+        ...Object.keys(accepted.documents),
+        ...Object.keys(accepted.revisions),
+        ...Object.keys(accepted.fileIds ?? {}),
+        ...Object.keys(accepted.changes),
+        ...Object.keys(accepted.binaryFiles ?? {}),
+        ...accepted.removals,
+    ]);
+    for (const change of submitted.changes) {
+        if (change.kind === 'move') {
+            paths.add(change.path);
+            paths.add(change.to);
+        }
+        if (change.kind === 'arrival')
+            paths.add(change.path);
+    }
+    return paths;
+}
+export function* returning(confirmed, submitted, accepted, writtenAt, composition) {
+    const documents = new Map();
+    const binaries = new Map();
+    const revisions = new Map();
+    const fileIds = new Map();
+    const created = new Map();
+    const changes = new Map();
+    const written = new Map();
+    const facts = new Map();
+    const read = (changed, held, path) => (changed.has(path) ? changed.get(path) : held[path]);
+    for (const [path, content] of Object.entries(accepted.documents)) {
+        yield ROW_WEIGHT + content.length;
+        documents.set(path, content);
+        facts.set(path, writtenFacts(path, content, composition));
+        fileIds.set(path, undefined);
+        written.set(path, writtenAt);
+    }
+    for (const [path, revision] of Object.entries(accepted.revisions)) {
+        yield ROW_WEIGHT;
+        revisions.set(path, revision);
+        fileIds.set(path, undefined);
+        if (confirmed.revisions[path] !== revision)
+            changes.set(path, undefined);
+    }
+    for (const [path, fileId] of Object.entries(accepted.fileIds ?? {}))
+        fileIds.set(path, fileId);
+    for (const [path, change] of Object.entries(accepted.changes))
+        changes.set(path, change);
+    for (const path of accepted.removals) {
+        documents.set(path, undefined);
+        revisions.set(path, undefined);
+        fileIds.set(path, undefined);
+        changes.set(path, undefined);
+        written.set(path, undefined);
+    }
+    for (const change of submitted.changes) {
+        if (change.kind === 'arrival') {
+            if (accepted.revisions[change.path] === undefined)
+                continue;
+            created.set(change.path, change.created);
+            if ('binary' in change)
+                binaries.set(change.path, { state: 'accepted', ...change.binary });
+            continue;
+        }
+        if (change.kind !== 'move' || accepted.revisions[change.to] === undefined)
+            continue;
+        created.set(change.to, read(created, confirmed.created, change.path));
+        created.set(change.path, undefined);
+        const moved = read(binaries, confirmed.binaries, change.path);
+        if (moved === undefined)
+            continue;
+        binaries.set(change.to, moved);
+        binaries.set(change.path, undefined);
+    }
+    for (const [path, binary] of acceptedBinaries(accepted.binaryFiles ?? {}))
+        binaries.set(path, binary);
+    for (const path of accepted.removals) {
+        binaries.set(path, undefined);
+        created.set(path, undefined);
+    }
+    const paths = new Set([
+        ...documents.keys(),
+        ...binaries.keys(),
+        ...revisions.keys(),
+        ...fileIds.keys(),
+        ...created.keys(),
+        ...changes.keys(),
+        ...written.keys(),
+    ]);
+    const set = [];
+    const removed = [];
+    for (const path of paths) {
+        const content = read(documents, confirmed.documents, path);
+        const binary = read(binaries, confirmed.binaries, path);
+        yield ROW_WEIGHT;
+        if (content === undefined && binary === undefined) {
+            removed.push(path);
+            continue;
+        }
+        const text = binary === undefined ? (content ?? null) : null;
+        const fresh = confirmed.documents[path] === undefined && confirmed.binaries[path] === undefined;
+        set.push({
+            path,
+            content: text,
+            facts: text === null ? null : (read(facts, confirmed.facts, path) ?? null),
+            binary: binary ?? null,
+            revision: read(revisions, confirmed.revisions, path) ?? null,
+            fileId: read(fileIds, confirmed.fileIds, path) ?? null,
+            created: read(created, confirmed.created, path) ??
+                (fresh ? (read(changes, confirmed.changes, path)?.time ?? null) : null),
+            change: read(changes, confirmed.changes, path) ?? null,
+            written: read(written, confirmed.written, path) ?? null,
+        });
+    }
+    return { set, removed };
+}

package/dist/retried.d.ts

@@ -0,0 +1,30 @@
+import { type RuntimeShell } from './durability.js';
+export declare const STEPS: readonly ['database', 'sign_in', 'connection', 'code', 'download', 'conversations', 'sending', 'reading'];
+export type Step = (typeof STEPS)[number];
+export type RetriedFailure = {
+    readonly step: Step;
+    readonly answered: false;
+} | {
+    readonly step: Step;
+    readonly answered: true;
+    readonly error: unknown;
+};
+export type Uncertain = {
+    readonly failure?: unknown;
+};
+export type Attempt = {
+    readonly step: Step;
+    readonly instance: string;
+};
+export declare class Unanswered extends Error {
+}
+export declare function uncertainError(uncertainty: Uncertain): unknown;
+export type Retries = {
+    failed(step: Step, instance: string, error: unknown): void;
+    unanswered(step: Step, instance: string): void;
+    uncertain(step: Step, instance: string, uncertainty: Uncertain): void;
+    succeeded(step: Step, instance: string): void;
+};
+export declare function createRetries(shell: Pick<RuntimeShell, 'retried' | 'succeeded'>): Retries;
+export declare function retrying<T>(retries: Retries, step: Step, instance: string, ask: () => Promise<T>): () => Promise<T>;
+//# sourceMappingURL=retried.d.ts.map

package/dist/retried.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retried.d.ts","sourceRoot":"","sources":["../src/retried.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,KAAK,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAErE,eAAO,MAAM,KAAK,YAChB,UAAU,EACV,SAAS,EACT,YAAY,EACZ,MAAM,EACN,UAAU,EACV,eAAe,EACf,SAAS,EACT,SAAS,CACD,CAAC;AAEX,MAAM,MAAM,IAAI,GAAG,CAAC,OAAO,KAAK,CAAC,CAAC,MAAM,CAAC,CAAC;AAE1C,MAAM,MAAM,cAAc,GACtB;IAAE,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,KAAK,CAAA;CAAE,GACjD;IAAE,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAAC;AAE9E,MAAM,MAAM,SAAS,GAAG;IAAE,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC;AAEvD,MAAM,MAAM,OAAO,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC;AAEzE,qBAAa,UAAW,SAAQ,KAAK;CAAG;AAExC,wBAAgB,cAAc,CAAC,WAAW,EAAE,SAAS,GAAG,OAAO,CAE9D;AAED,MAAM,MAAM,OAAO,GAAG;IACpB,MAAM,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;IAC3D,UAAU,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/C,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,SAAS,GAAG,IAAI,CAAC;IACtE,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/C,CAAC;AAEF,wBAAgB,aAAa,CAAC,KAAK,EAAE,IAAI,CAAC,YAAY,EAAE,SAAS,GAAG,WAAW,CAAC,GAAG,OAAO,CA2CzF;AAED,wBAAgB,QAAQ,CAAC,CAAC,EACxB,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,IAAI,EACV,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GACpB,MAAM,OAAO,CAAC,CAAC,CAAC,CAYlB"}