@graview/react 0.1.0

package/LICENSE

@@ -0,0 +1,96 @@
+Elastic License 2.0
+
+## Acceptance
+
+By using the software, you agree to all of the terms and conditions below.
+
+## Copyright License
+
+The licensor grants you a non-exclusive, royalty-free, worldwide,
+non-sublicensable, non-transferable license to use, copy, distribute, make
+available, and prepare derivative works of the software, in each case subject
+to the limitations and conditions below.
+
+## Limitations
+
+You may not provide the software to third parties as a hosted or managed
+service, where the service provides users with access to any substantial set
+of the features or functionality of the software.
+
+You may not move, change, disable, or circumvent the license key
+functionality in the software, and you may not remove or obscure any
+functionality in the software that is protected by the license key.
+
+You may not alter, remove, or obscure any licensing, copyright, or other
+notices of the licensor in the software. Any use of the licensor's trademarks
+is subject to applicable law.
+
+## Patents
+
+The licensor grants you a license, under any patent claims the licensor can
+license, or becomes able to license, to make, have made, use, sell, offer for
+sale, import and have imported the software, in each case subject to the
+limitations and conditions in this license. This license does not cover any
+patent claims that you cause to be infringed by modifications or additions to
+the software. If you or your company make any written claim that the software
+infringes or contributes to infringement of any patent, your patent license
+for the software granted under these terms ends immediately. If your company
+makes such a claim, your patent license ends immediately for work on behalf
+of your company.
+
+## Notices
+
+You must ensure that anyone who gets a copy of any part of the software from
+you also gets a copy of these terms.
+
+If you modify the software, you must include in any modified copies of the
+software prominent notices stating that you have modified the software.
+
+## No Other Rights
+
+These terms do not imply any licenses other than those expressly granted in
+these terms.
+
+## Termination
+
+If you use the software in violation of these terms, such use is not
+licensed, and your licenses will automatically terminate. If the licensor
+provides you with a notice of your violation, and you cease all violation of
+this license no later than 30 days after you receive that notice, your
+licenses will be reinstated retroactively. However, if you violate these
+terms after such reinstatement, any additional violation of these terms will
+cause your licenses to terminate automatically and permanently.
+
+## No Liability
+
+*As far as the law allows, the software comes as is, without any warranty or
+condition, and the licensor will not be liable to you for any damages arising
+out of these terms or the use or nature of the software, under any kind of
+legal claim.*
+
+## Definitions
+
+The **licensor** is the entity offering these terms, and the **software** is
+the software the licensor makes available under these terms, including any
+portion of it.
+
+**you** refers to the individual or entity agreeing to these terms.
+
+**your company** is any legal entity, sole proprietorship, or other kind of
+organization that you work for, plus all organizations that have control
+over, are under the control of, or are under common control with that
+organization. **control** means ownership of substantially all the assets of
+an entity, or the power to direct its management and policies by vote,
+contract, or otherwise. Control can be direct or indirect.
+
+**your licenses** are all the licenses granted to you for the software under
+these terms.
+
+**use** means anything you do with the software requiring one of your
+licenses.
+
+**trademark** means trademarks, service marks, and similar rights.
+
+---
+
+Copyright 2025-2026 En Dash Consulting

package/README.md

@@ -0,0 +1,20 @@
+# @graview/react
+
+The binding. A provider, a scene, and the hooks an app builds on.
+
+A view is an ORDINARY React component. No scene API, no base class — that is
+the whole authoring surface, and it is the reason the capture approach earns
+its cost. Every view must render correctly in both modes: captured into the
+scene, and lifted out as a full page.
+
+```tsx
+<GraviewProvider store={store} views={views} brand={brand} principal={me}>
+  <Scene />
+  <JackedIn />
+</GraviewProvider>
+```
+
+The provider holds the store, the view registry, the current view, the
+selection, the activity and the principal — together, so the scene, the chrome
+and an agent seat are looking at the same thing rather than at three copies of
+it.

package/dist/activity.d.ts

@@ -0,0 +1,113 @@
+import { type AnySchema, type Author, type Operation, type Store } from "@graview/core";
+/**
+ * Who was moving, in the terms the op log already records.
+ *
+ * `directed` is a person; `autonomous` is an agent taking a turn of its own;
+ * `co-edited` is more than one participant on the same thing inside the
+ * window; `rule` is the invariant engine repairing something. Nothing new is
+ * invented to tell them apart — every op carries an author with a kind, an
+ * id and a session, and this is only a reading of it.
+ */
+export type Manner = "directed" | "autonomous" | "co-edited" | "rule";
+export interface ActivityMark {
+    /** When it happened, in `performance.now()`-comparable milliseconds. */
+    readonly at: number;
+    readonly manner: Manner;
+    /** What was MEANT, from the op. Not a description of what changed. */
+    readonly intent: string;
+    /** Something here was written. */
+    readonly wrote: boolean;
+    /**
+     * Something here was READ while deciding, and not written.
+     *
+     * This is the half a diff cannot show, and the half that makes an agent's
+     * turn legible: what it looked at before it moved says more about whether
+     * to trust the move than the move does.
+     */
+    readonly read: boolean;
+    /** A rule that implicates this began failing with this change. */
+    readonly broke: boolean;
+    /** Distinct participants, so a second one turns the mark into `co-edited`. */
+    readonly participants: readonly string[];
+}
+/**
+ * Folds one notification into the marks that are still current.
+ *
+ * Pure, and separate from the hook, because "what does the picture say after
+ * an agent turn" is a question worth being able to ask without a renderer.
+ */
+export declare function markActivity(previous: ReadonlyMap<string, ActivityMark>, ops: readonly Operation[], broken: readonly BrokenRule[], at: number, holdMs: number): Map<string, ActivityMark>;
+/** A violation that was not failing a moment ago. */
+export interface BrokenRule {
+    readonly nodeIds: readonly string[];
+    readonly message: string;
+}
+/**
+ * What has just happened, per node, for a few seconds.
+ *
+ * The overview is the place to WATCH the system work — an edit landing, a
+ * rule starting to fail, an agent reading its way to a decision — and all of
+ * it is already in the op log. This turns the log into something a picture
+ * can read.
+ *
+ * The state lives in the provider rather than here for the same reason
+ * selection does: the scene, the chrome and an agent seat must all be
+ * looking at the same activity, or the picture and the list disagree about
+ * what just happened.
+ *
+ * It costs nothing on a quiet graph. There is no animation loop and no
+ * polling: a subscription that never fires schedules no timer, and the marks
+ * are cleared by a single timeout rather than by a frame callback checking
+ * whether they have expired.
+ */
+export declare function useActivity<S extends AnySchema>(): ReadonlyMap<string, ActivityMark>;
+/** How long a mark stays up. Long enough to notice, short enough to mean "just". */
+export declare const ACTIVITY_HOLD_MS = 2600;
+/**
+ * The activity state itself, owned by the provider.
+ *
+ * Returns the marks and the way to add attention that never became an op —
+ * an agent reading the graph changes nothing and produces no diff, which is
+ * exactly why it needs its own way in.
+ */
+export declare function useActivityState<S extends AnySchema>(store: Store<S>, holdMs?: number): {
+    activity: ReadonlyMap<string, ActivityMark>;
+    noteAttention: (note: Attention) => void;
+};
+/**
+ * Something looked at, by someone, for a reason.
+ *
+ * A read leaves no diff and no operation, so there is nothing in the log to
+ * fold. This is the one thing the interface is told rather than derived —
+ * and it is told by the tool runtime, which is the only thing that knows.
+ */
+export interface Attention {
+    readonly reads: readonly string[];
+    readonly author: Author;
+    readonly intent: string;
+}
+/**
+ * Pipes an agent seat's read-only tool calls into the picture.
+ *
+ * What an agent READ is the half a diff cannot show, and the half that says
+ * whether to trust what it then did. The runtime already announces every
+ * call with the nodes it looked at; this is the wire.
+ */
+export declare function useAttention(runtime: {
+    readonly author?: Author;
+    onCall(listener: (call: ToolCallLike) => void): () => void;
+}): void;
+/**
+ * The shape of a settled tool call, structurally.
+ *
+ * Declared here rather than imported so that the react binding does not take
+ * a dependency on the tool runtime for the sake of one field: anything that
+ * announces calls in this shape can be watched.
+ */
+export interface ToolCallLike {
+    readonly name: string;
+    readonly phase: "running" | "ok" | "failed";
+    readonly reads?: readonly string[];
+    readonly args?: Readonly<Record<string, unknown>>;
+}
+//# sourceMappingURL=activity.d.ts.map

package/dist/activity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"activity.d.ts","sourceRoot":"","sources":["../src/activity.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,KAAK,SAAS,EAAE,KAAK,MAAM,EAAE,KAAK,SAAS,EAAE,KAAK,KAAK,EAAE,MAAM,eAAe,CAAC;AAItG;;;;;;;;GAQG;AACH,MAAM,MAAM,MAAM,GAAG,UAAU,GAAG,YAAY,GAAG,WAAW,GAAG,MAAM,CAAC;AAEtE,MAAM,WAAW,YAAY;IAC3B,wEAAwE;IACxE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,sEAAsE;IACtE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,kCAAkC;IAClC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB;;;;;;OAMG;IACH,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,kEAAkE;IAClE,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,8EAA8E;IAC9E,QAAQ,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;CAC1C;AAeD;;;;;GAKG;AACH,wBAAgB,YAAY,CAC1B,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,YAAY,CAAC,EAC3C,GAAG,EAAE,SAAS,SAAS,EAAE,EACzB,MAAM,EAAE,SAAS,UAAU,EAAE,EAC7B,EAAE,EAAE,MAAM,EACV,MAAM,EAAE,MAAM,GACb,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CA8D3B;AAED,qDAAqD;AACrD,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,SAAS,KAAK,WAAW,CAAC,MAAM,EAAE,YAAY,CAAC,CAEpF;AAED,oFAAoF;AACpF,eAAO,MAAM,gBAAgB,OAAO,CAAC;AAErC;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,SAAS,EAClD,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,EACf,MAAM,SAAmB,GACxB;IACD,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IAC5C,aAAa,EAAE,CAAC,IAAI,EAAE,SAAS,KAAK,IAAI,CAAC;CAC1C,CA+DA;AAED;;;;;;GAMG;AACH,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAyBD;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE;IACpC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,MAAM,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,YAAY,KAAK,IAAI,GAAG,MAAM,IAAI,CAAC;CAC5D,GAAG,IAAI,CA2BP;AAED;;;;;;GAMG;AACH,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI,GAAG,QAAQ,CAAC;IAC5C,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,QAAQ,CAAC,IAAI,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CACnD"}

package/dist/activity.js

@@ -0,0 +1,207 @@
+import { violationKey } from "@graview/core";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { useGraview } from "./context.js";
+/** One author's identity across a window. Session is what separates two agents. */
+function participantOf(op) {
+    const { kind, id, session } = op.author;
+    return `${kind}:${id ?? ""}:${session ?? ""}`;
+}
+function mannerOf(participants, last) {
+    if (participants.length > 1)
+        return "co-edited";
+    if (last === "rule")
+        return "rule";
+    return last === "agent" ? "autonomous" : "directed";
+}
+/**
+ * Folds one notification into the marks that are still current.
+ *
+ * Pure, and separate from the hook, because "what does the picture say after
+ * an agent turn" is a question worth being able to ask without a renderer.
+ */
+export function markActivity(previous, ops, broken, at, holdMs) {
+    const next = new Map();
+    // Anything still inside the window survives, so two changes a second apart
+    // read as two things happening rather than the second erasing the first.
+    for (const [id, mark] of previous) {
+        if (at - mark.at < holdMs)
+            next.set(id, mark);
+    }
+    const broke = new Set(broken.flatMap((violation) => violation.nodeIds));
+    const touch = (id, op, fields) => {
+        const existing = next.get(id);
+        const participants = existing?.participants.includes(participantOf(op))
+            ? existing.participants
+            : [...(existing?.participants ?? []), participantOf(op)];
+        next.set(id, {
+            at,
+            manner: mannerOf(participants, op.author.kind),
+            intent: op.intent,
+            wrote: (existing?.wrote ?? false) || (fields.wrote ?? false),
+            // A write outranks a read: once something was changed, saying it was
+            // also looked at adds nothing.
+            read: ((existing?.read ?? false) || (fields.read ?? false)),
+            broke: (existing?.broke ?? false) || broke.has(id),
+            participants,
+        });
+    };
+    for (const op of ops) {
+        for (const id of op.writes)
+            touch(id, op, { wrote: true });
+        for (const id of op.reads) {
+            if (op.writes.includes(id))
+                continue;
+            touch(id, op, { read: true });
+        }
+    }
+    /*
+     * A rule that has just begun to fail marks EVERY node it implicates, not
+     * only the one that was written.
+     *
+     * That is the whole point of watching from up here: the change lands on
+     * one card and the consequence appears on another, and seeing the second
+     * without having gone looking for it is the thing a list of diffs cannot
+     * do. The rule speaks in its own voice — its message is the intent.
+     */
+    for (const violation of broken) {
+        for (const id of violation.nodeIds) {
+            const existing = next.get(id);
+            next.set(id, {
+                at,
+                manner: existing?.manner ?? "rule",
+                intent: existing?.intent ?? violation.message,
+                wrote: existing?.wrote ?? false,
+                read: existing?.read ?? false,
+                broke: true,
+                participants: existing?.participants ?? ["rule::"],
+            });
+        }
+    }
+    return next;
+}
+/**
+ * What has just happened, per node, for a few seconds.
+ *
+ * The overview is the place to WATCH the system work — an edit landing, a
+ * rule starting to fail, an agent reading its way to a decision — and all of
+ * it is already in the op log. This turns the log into something a picture
+ * can read.
+ *
+ * The state lives in the provider rather than here for the same reason
+ * selection does: the scene, the chrome and an agent seat must all be
+ * looking at the same activity, or the picture and the list disagree about
+ * what just happened.
+ *
+ * It costs nothing on a quiet graph. There is no animation loop and no
+ * polling: a subscription that never fires schedules no timer, and the marks
+ * are cleared by a single timeout rather than by a frame callback checking
+ * whether they have expired.
+ */
+export function useActivity() {
+    return useGraview().activity;
+}
+/** How long a mark stays up. Long enough to notice, short enough to mean "just". */
+export const ACTIVITY_HOLD_MS = 2600;
+/**
+ * The activity state itself, owned by the provider.
+ *
+ * Returns the marks and the way to add attention that never became an op —
+ * an agent reading the graph changes nothing and produces no diff, which is
+ * exactly why it needs its own way in.
+ */
+export function useActivityState(store, holdMs = ACTIVITY_HOLD_MS) {
+    const [marks, setMarks] = useState(() => new Map());
+    const live = useRef(marks);
+    live.current = marks;
+    // One timer for the whole thing, reset by whatever happened last. A quiet
+    // graph holds no timer at all.
+    const timer = useRef(null);
+    const publish = useCallback((next) => {
+        live.current = next;
+        setMarks(next);
+        if (timer.current)
+            clearTimeout(timer.current);
+        timer.current = setTimeout(() => {
+            live.current = new Map();
+            setMarks(new Map());
+        }, holdMs);
+    }, [holdMs]);
+    useEffect(() => {
+        let failing = new Set(store.violations().map(violationKey));
+        const unsubscribe = store.subscribe((_diff, ops) => {
+            const after = store.violations();
+            const fresh = after.filter((violation) => !failing.has(violationKey(violation)));
+            failing = new Set(after.map(violationKey));
+            publish(markActivity(live.current, ops, fresh.map((violation) => ({
+                nodeIds: violation.nodeIds,
+                message: violation.message,
+            })), Date.now(), holdMs));
+        });
+        return () => {
+            unsubscribe();
+            if (timer.current)
+                clearTimeout(timer.current);
+        };
+    }, [store, holdMs, publish]);
+    const noteAttention = useCallback((note) => {
+        if (note.reads.length === 0)
+            return;
+        publish(markActivity(live.current, [attentionAsOp(note)], [], Date.now(), holdMs));
+    }, [holdMs, publish]);
+    return { activity: marks, noteAttention };
+}
+/**
+ * A read dressed as an operation, so it walks the same path a write does.
+ *
+ * Not appended to any log — the log is for things that happened to the
+ * graph, and looking at something did not. This exists only so `markActivity`
+ * has one shape to fold rather than two.
+ */
+function attentionAsOp(note) {
+    return {
+        id: `attention:${note.intent}`,
+        seq: -1,
+        batch: "attention",
+        author: note.author,
+        intent: note.intent,
+        mutation: null,
+        primitives: [],
+        inverse: [],
+        reads: note.reads,
+        writes: [],
+        at: new Date().toISOString(),
+    };
+}
+/**
+ * Pipes an agent seat's read-only tool calls into the picture.
+ *
+ * What an agent READ is the half a diff cannot show, and the half that says
+ * whether to trust what it then did. The runtime already announces every
+ * call with the nodes it looked at; this is the wire.
+ */
+export function useAttention(runtime) {
+    const { noteAttention, noteSeat } = useGraview();
+    useEffect(() => runtime.onCall((call) => {
+        const author = runtime.author ?? { kind: "agent" };
+        /*
+         * WHAT A CALL SAYS reaches the body: a run's stop reason, a loop's
+         * sentence — announced as a `stop` call carrying `said` — is said
+         * from the robot, not only written to the rail.
+         */
+        const said = call.args?.["said"];
+        if (call.phase === "ok" && typeof said === "string" && said.length > 0) {
+            noteSeat({ type: "said", author, say: said });
+        }
+        if (call.phase !== "ok" || !call.reads || call.reads.length === 0)
+            return;
+        noteAttention({
+            reads: call.reads,
+            // The seat's OWN author, not a generic agent: attributing a read to
+            // a different participant than the writes makes one agent looking
+            // and then moving read as two people editing at once.
+            author,
+            intent: `read ${call.name}`,
+        });
+    }), [runtime, noteAttention, noteSeat]);
+}
+//# sourceMappingURL=activity.js.map

package/dist/activity.js.map

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

package/dist/animation.d.ts

@@ -0,0 +1,64 @@
+import { type InterpolatedLayout, type Layout } from "@graview/layout";
+import type { AnySchema } from "@graview/core";
+export interface TransitionOptions {
+    /** Milliseconds. Long enough to follow, short enough not to wait for. */
+    readonly duration?: number;
+    /** Skip animation entirely — tests, SSR, reduced-motion. */
+    readonly enabled?: boolean;
+}
+/**
+ * Tweens between two layouts whenever the view changes.
+ *
+ * This is the pay-off for layout being a pure function: there is no list of
+ * known transitions and no per-navigation animation code. ANY two view states
+ * interpolate, so a kind of navigation nobody anticipated animates the same
+ * as the ones that were designed — and a node entering the scene grows out of
+ * whatever group stood in for it, because the interpolation knows where it
+ * came from.
+ *
+ * Motion is the one thing that makes depth legible. Without it, a plane
+ * change is a cut and the viewer has to re-find everything; with it, the eye
+ * follows and spatial memory survives the move.
+ */
+export declare function useAnimatedLayout(target: Layout, options?: TransitionOptions): InterpolatedLayout;
+/**
+ * The nodes implicated by the most recent change, for about a second.
+ *
+ * Human and agent edits arrive through the same subscription carrying the
+ * same diff, so the interface cannot render one differently from the other
+ * even by accident — which is the point. The renderer highlights an agent's
+ * work with exactly the code that highlights yours.
+ */
+export declare function useTouched<S extends AnySchema>(holdMs?: number): ReadonlySet<string>;
+/** One thing the seat did, and what it touched. */
+export interface SeatAct {
+    readonly batch: string;
+    /** The agent's own name, from the op's author. */
+    readonly who: string;
+    readonly intent: string;
+    readonly at: string;
+    readonly wrote: readonly string[];
+}
+export interface SeatWork {
+    /** Node id → the seat that wrote it, while the mark stands. */
+    readonly marks: ReadonlyMap<string, string>;
+    /** What the seat has done this session, newest first — the companion's log. */
+    readonly acts: readonly SeatAct[];
+}
+/**
+ * WHERE THE SEAT WORKED, MARKED ON THE THINGS THEMSELVES.
+ *
+ * The robot used to walk to what it wrote and stand there, which is the
+ * one thing the body was genuinely good for: attribution in space. The
+ * walk is gone; the attribution is not. Every op the log attributes to an
+ * agent marks what it wrote for a hold, and the acts stay in a list the
+ * companion can offer to fly you to.
+ *
+ * Read from the OP LOG rather than from the seat's own reports, so it is
+ * the same on both render paths, inside a lens, and for a turn that
+ * arrived from somewhere else entirely. An undo takes its marks with it:
+ * an op that undoes another says so, and what it took back stops being
+ * something the seat just did.
+ */
+export declare function useSeatWork<S extends AnySchema>(holdMs?: number): SeatWork;
+//# sourceMappingURL=animation.d.ts.map

package/dist/animation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animation.d.ts","sourceRoot":"","sources":["../src/animation.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,kBAAkB,EACvB,KAAK,MAAM,EACZ,MAAM,iBAAiB,CAAC;AAEzB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAG/C,MAAM,WAAW,iBAAiB;IAChC,yEAAyE;IACzE,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,4DAA4D;IAC5D,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;CAC5B;AASD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,iBAAsB,GAC9B,kBAAkB,CA4HpB;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,SAAS,EAAE,MAAM,SAAO,GAAG,WAAW,CAAC,MAAM,CAAC,CAkBlF;AAED,mDAAmD;AACnD,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,kDAAkD;IAClD,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;CACnC;AAED,MAAM,WAAW,QAAQ;IACvB,+DAA+D;IAC/D,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC5C,+EAA+E;IAC/E,QAAQ,CAAC,IAAI,EAAE,SAAS,OAAO,EAAE,CAAC;CACnC;AAID;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,SAAS,EAAE,MAAM,SAAO,GAAG,QAAQ,CAuDxE"}