@assistant-ui/store 0.1.6 → 0.2.1

package/src/tapClientResource.ts

@@ -4,9 +4,8 @@ import {
   tapRef,
   type ResourceElement,
   tapResource,
-  tapInlineResource,
 } from "@assistant-ui/tap";
-import type { ClientMethods, ClientOutputOf } from "./types/client";
+import type { ClientMethods } from "./types/client";
 import {
   tapClientStack,
   tapWithClientStack,
@@ -25,7 +24,7 @@ import { wrapperResource } from "./wrapperResource";
 const SYMBOL_GET_OUTPUT = Symbol("assistant-ui.store.getValue");
 
 type ClientInternal = {
-  [SYMBOL_GET_OUTPUT]: ClientOutputOf<unknown, ClientMethods>;
+  [SYMBOL_GET_OUTPUT]: ClientMethods;
 };
 
 export const getClientState = (client: ClientMethods) => {
@@ -36,7 +35,7 @@ export const getClientState = (client: ClientMethods) => {
         "Ensure your Derived get() returns a client created with tapClientResource(), not a plain resource.",
     );
   }
-  return output.state;
+  return (output as any).getState?.();
 };
 
 // Global cache for function templates by field name
@@ -64,7 +63,7 @@ function getOrCreateProxyFn(prop: string | symbol) {
         );
       }
 
-      const method = output.methods[prop];
+      const method = output[prop];
       if (!method)
         throw new Error(`Method "${String(prop)}" is not implemented.`);
       if (typeof method !== "function")
@@ -85,7 +84,7 @@ class ClientProxyHandler
 
   constructor(
     private readonly outputRef: {
-      current: ClientOutputOf<unknown, ClientMethods>;
+      current: ClientMethods;
     },
     private readonly index: number,
   ) {
@@ -97,7 +96,7 @@ class ClientProxyHandler
     if (prop === SYMBOL_CLIENT_INDEX) return this.index;
     const introspection = handleIntrospectionProp(prop, "ClientProxy");
     if (introspection !== false) return introspection;
-    const value = this.outputRef.current.methods[prop];
+    const value = this.outputRef.current[prop];
     if (typeof value === "function") {
       if (this.cachedReceiver !== receiver) {
         this.boundFns = new Map();
@@ -114,43 +113,34 @@ class ClientProxyHandler
   }
 
   ownKeys(): ArrayLike<string | symbol> {
-    return Object.keys(this.outputRef.current.methods);
+    return Object.keys(this.outputRef.current);
   }
 
   has(_: unknown, prop: string | symbol) {
     if (prop === SYMBOL_GET_OUTPUT) return true;
     if (prop === SYMBOL_CLIENT_INDEX) return true;
-    return prop in this.outputRef.current.methods;
+    return prop in this.outputRef.current;
   }
 }
 
 /**
  * Resource that wraps a plain resource element to create a stable client proxy.
  *
- * Takes a ResourceElement that returns { state, methods } and
+ * Takes a ResourceElement that returns methods (with optional getState()) and
  * wraps it to produce a stable client proxy. This adds the client to the
  * client stack, enabling event scoping.
  *
- * Use this for 1:1 client mappings where you want event scoping to work correctly.
- *
- * @example
- * ```typescript
- * const MessageResource = resource(({ messageId }: { messageId: string }) => {
- *   return tapInlineResource(
- *     tapClientResource(InnerMessageResource({ messageId }))
- *   );
- * });
- * ```
+ * @internal
  */
 export const ClientResource = wrapperResource(
-  <TState, TMethods extends ClientMethods>(
-    element: ResourceElement<ClientOutputOf<TState, TMethods>>,
-  ): ClientOutputOf<TState, TMethods> & {
+  <TMethods extends ClientMethods>(
+    element: ResourceElement<TMethods>,
+  ): {
+    methods: TMethods;
+    state: unknown;
     key: string | number | undefined;
   } => {
-    const valueRef = tapRef(
-      null as unknown as ClientOutputOf<TState, TMethods>,
-    );
+    const valueRef = tapRef(null as unknown as TMethods);
 
     const index = tapClientStack().length;
     const methods = tapMemo(
@@ -171,12 +161,27 @@ export const ClientResource = wrapperResource(
       valueRef.current = value;
     });
 
-    return { methods, state: value.state, key: element.key };
+    const state = (value as any).getState?.();
+    return { methods, state, key: element.key };
   },
 );
 
-export const tapClientResource = <TState, TMethods extends ClientMethods>(
-  element: ResourceElement<ClientOutputOf<TState, TMethods>>,
-) => {
-  return tapInlineResource(ClientResource(element));
+type InferClientState<TMethods> = TMethods extends {
+  getState: () => infer S;
+}
+  ? S
+  : undefined;
+
+export const tapClientResource = <TMethods extends ClientMethods>(
+  element: ResourceElement<TMethods>,
+): {
+  state: InferClientState<TMethods>;
+  methods: TMethods;
+  key: string | number | undefined;
+} => {
+  return tapResource(ClientResource(element)) as {
+    state: InferClientState<TMethods>;
+    methods: TMethods;
+    key: string | number | undefined;
+  };
 };

package/src/types/client.ts

@@ -9,7 +9,7 @@ import type {
  * Base type for methods that can be called on a client.
  */
 export interface ClientMethods {
-  [key: string | symbol]: ((...args: any[]) => any) | ClientMethods;
+  [key: string | symbol]: (...args: any[]) => any;
 }
 
 type ClientMetaType = { source: ClientNames; query: Record<string, unknown> };
@@ -23,12 +23,10 @@ type ClientMetaType = { source: ClientNames; query: Record<string, unknown> };
  * @internal
  */
 export type ClientSchema<
-  TState = unknown,
   TMethods extends ClientMethods = ClientMethods,
   TMeta extends ClientMetaType = never,
   TEvents extends Record<string, unknown> = never,
 > = {
-  state: TState;
   methods: TMethods;
   meta?: TMeta;
   events?: TEvents;
@@ -40,16 +38,20 @@ export type ClientSchema<
  * @example
  * ```typescript
  * declare module "@assistant-ui/store" {
- *   interface ClientRegistry {
+ *   interface ScopeRegistry {
  *     // Simple client (meta and events are optional)
  *     foo: {
- *       state: { bar: string };
- *       methods: { updateBar: (bar: string) => void };
+ *       methods: {
+ *         getState: () => { bar: string };
+ *         updateBar: (bar: string) => void;
+ *       };
  *     };
  *     // Full client with meta and events
  *     bar: {
- *       state: { id: string };
- *       methods: { update: () => void };
+ *       methods: {
+ *         getState: () => { id: string };
+ *         update: () => void;
+ *       };
  *       meta: { source: "fooList"; query: { index: number } };
  *       events: {
  *         "bar.updated": { id: string };
@@ -59,7 +61,7 @@ export type ClientSchema<
  * }
  * ```
  */
-export interface ClientRegistry {}
+export interface ScopeRegistry {}
 
 type ClientEventsType<K extends ClientNames> = Record<
   `${K}.${string}`,
@@ -67,63 +69,51 @@ type ClientEventsType<K extends ClientNames> = Record<
 >;
 
 type ClientError<E extends string> = {
-  state: E;
   methods: Record<E, () => E>;
   meta: { source: ClientNames; query: Record<E, E> };
   events: Record<`${E}.`, E>;
 };
 
-type ValidateClient<K extends keyof ClientRegistry> =
-  ClientRegistry[K] extends { methods: ClientMethods }
-    ? "meta" extends keyof ClientRegistry[K]
-      ? ClientRegistry[K]["meta"] extends ClientMetaType
-        ? "events" extends keyof ClientRegistry[K]
-          ? ClientRegistry[K]["events"] extends ClientEventsType<K>
-            ? ClientRegistry[K]
-            : ClientError<`ERROR: ${K & string} has invalid events type`>
-          : ClientRegistry[K]
-        : ClientError<`ERROR: ${K & string} has invalid meta type`>
-      : "events" extends keyof ClientRegistry[K]
-        ? ClientRegistry[K]["events"] extends ClientEventsType<K>
-          ? ClientRegistry[K]
+type ValidateClient<K extends keyof ScopeRegistry> = ScopeRegistry[K] extends {
+  methods: ClientMethods;
+}
+  ? "meta" extends keyof ScopeRegistry[K]
+    ? ScopeRegistry[K]["meta"] extends ClientMetaType
+      ? "events" extends keyof ScopeRegistry[K]
+        ? ScopeRegistry[K]["events"] extends ClientEventsType<K>
+          ? ScopeRegistry[K]
           : ClientError<`ERROR: ${K & string} has invalid events type`>
-        : ClientRegistry[K]
-    : ClientError<`ERROR: ${K & string} has invalid methods type`>;
-
-type ClientSchemas = keyof ClientRegistry extends never
+        : ScopeRegistry[K]
+      : ClientError<`ERROR: ${K & string} has invalid meta type`>
+    : "events" extends keyof ScopeRegistry[K]
+      ? ScopeRegistry[K]["events"] extends ClientEventsType<K>
+        ? ScopeRegistry[K]
+        : ClientError<`ERROR: ${K & string} has invalid events type`>
+      : ScopeRegistry[K]
+  : ClientError<`ERROR: ${K & string} has invalid methods type`>;
+
+type ClientSchemas = keyof ScopeRegistry extends never
   ? {
       "ERROR: No clients were defined": ClientError<"ERROR: No clients were defined">;
     }
-  : { [K in keyof ClientRegistry]: ValidateClient<K> };
+  : { [K in keyof ScopeRegistry]: ValidateClient<K> };
 
 /**
- * Output type that client resources return with state and methods.
+ * Output type that client resources return (just methods).
  *
  * @example
  * ```typescript
  * const FooResource = resource((): ClientResourceOutput<"foo"> => {
  *   const [state, setState] = tapState({ bar: "hello" });
  *   return {
- *     state,
- *     methods: {
- *       updateBar: (b) => setState({ bar: b })
- *     }
+ *     getState: () => state,
+ *     updateBar: (b) => setState({ bar: b }),
  *   };
  * });
  * ```
  */
-export type ClientOutput<K extends ClientNames> = ClientOutputOf<
-  ClientSchemas[K]["state"],
-  ClientSchemas[K]["methods"] & ClientMethods
->;
-
-/**
- * Generic version of ClientResourceOutput for library code.
- */
-export type ClientOutputOf<TState, TMethods extends ClientMethods> = {
-  state: TState;
-  methods: TMethods;
-};
+export type ClientOutput<K extends ClientNames> = ClientSchemas[K]["methods"] &
+  ClientMethods;
 
 export type ClientNames = keyof ClientSchemas extends infer U ? U : never;
 
@@ -154,10 +144,14 @@ export type ClientElement<K extends ClientNames> = ResourceElement<
 export type Unsubscribe = () => void;
 
 /**
- * State type extracted from all clients.
+ * State type extracted from all clients via their getState() methods.
  */
 export type AssistantState = {
-  [K in ClientNames]: ClientSchemas[K]["state"];
+  [K in ClientNames]: ClientSchemas[K]["methods"] extends {
+    getState: () => infer S;
+  }
+    ? S
+    : never;
 };
 
 /**

package/src/{useAui.tsx → useAui.ts}

@@ -6,12 +6,11 @@ import {
   tapMemo,
   tapResources,
   tapEffectEvent,
-  tapInlineResource,
   tapEffect,
   tapRef,
   tapResource,
   withKey,
-  tapSubscribableResource,
+  tapResourceRoot,
 } from "@assistant-ui/tap";
 import type {
   AssistantClient,
@@ -46,7 +45,7 @@ import {
   createProxiedAssistantState,
 } from "./utils/proxied-assistant-state";
 
-const tapShallowMemoArray = <T,>(array: readonly T[]) => {
+const tapShallowMemoArray = <T>(array: readonly T[]) => {
   // biome-ignore lint/correctness/useExhaustiveDependencies: shallow memo
   return tapMemo(() => array, array);
 };
@@ -81,7 +80,7 @@ const RootClientAccessorResource = resource(
     clientRef: { parent: AssistantClient; current: AssistantClient | null };
     name: K;
   }): AssistantClientAccessor<K> => {
-    const store = tapSubscribableResource(
+    const store = tapResourceRoot(
       RootClientResource({ element, emit: notifications.emit, clientRef }),
     );
 
@@ -129,7 +128,7 @@ const RootClientsAccessorsResource = resource(
     clients: RootClients;
     clientRef: { parent: AssistantClient; current: AssistantClient | null };
   }) => {
-    const notifications = tapInlineResource(NotificationManager());
+    const notifications = tapResource(NotificationManager());
 
     tapEffect(
       () => clientRef.parent.subscribe(notifications.notifySubscribers),
@@ -318,7 +317,7 @@ export const AssistantClientResource = resource(
         : NoOpRootClientsAccessorsResource(),
     );
 
-    const derivedFields = tapInlineResource(
+    const derivedFields = tapResource(
       DerivedClientsAccessorsResource({ clients: derivedClients, clientRef }),
     );
 

package/src/{useAuiState.tsx → useAuiState.ts}

@@ -15,10 +15,10 @@ import { getProxiedAssistantState } from "./utils/proxied-assistant-state";
  *   foo: RootScope({ ... }),
  * });
  *
- * const bar = useAuiState((state) => state.foo.bar);
+ * const bar = useAuiState((s) => s.foo.bar);
  * ```
  */
-export const useAuiState = <T,>(selector: (state: AssistantState) => T): T => {
+export const useAuiState = <T>(selector: (state: AssistantState) => T): T => {
   const aui = useAui();
   const proxiedState = getProxiedAssistantState(aui);
 

package/src/utils/splitClients.ts

@@ -4,7 +4,7 @@ import type {
   ClientElement,
   ClientNames,
 } from "../types/client";
-import { getDefaultPeers } from "../attachDefaultPeers";
+import { getTransformScopes } from "../attachTransformScopes";
 import type { useAui } from "../useAui";
 import { tapMemo } from "@assistant-ui/tap";
 
@@ -16,99 +16,49 @@ export type DerivedClients = Partial<
 >;
 
 /**
- * Splits a clients object into root clients and derived clients.
- *
- * @param clients - The clients input object to split
- * @returns An object with { rootClients, derivedClients }
- *
- * @example
- * ```typescript
- * const clients = {
- *   foo: RootClient({ ... }),
- *   bar: Derived({ ... }),
- * };
- *
- * const { rootClients, derivedClients } = splitClients(clients);
- * // rootClients = { foo: ... }
- * // derivedClients = { bar: ... }
- * ```
+ * Splits a clients object into root clients and derived clients,
+ * applying transformScopes from root client elements.
  */
 function splitClients(clients: useAui.Props, baseClient: AssistantClient) {
+  // 1. Collect transforms from root elements and run them iteratively
+  let scopes = { ...clients } as Record<
+    string,
+    ClientElement<ClientNames> | DerivedElement<ClientNames>
+  >;
+  const visited = new Set<(...args: any[]) => any>();
+
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const clientElement of Object.values(scopes)) {
+      if (clientElement.type === (Derived as unknown)) continue;
+      if (visited.has(clientElement.type)) continue;
+      visited.add(clientElement.type);
+
+      const transform = getTransformScopes(clientElement.type);
+      if (transform) {
+        scopes = transform(scopes, baseClient) as typeof scopes;
+        changed = true;
+        break; // restart iteration since scopes may have new root elements
+      }
+    }
+  }
+
+  // 2. Split result into root/derived
   const rootClients: RootClients = {};
   const derivedClients: DerivedClients = {};
 
-  for (const [key, clientElement] of Object.entries(clients) as [
-    keyof useAui.Props,
-    NonNullable<useAui.Props[keyof useAui.Props]>,
+  for (const [key, clientElement] of Object.entries(scopes) as [
+    ClientNames,
+    ClientElement<ClientNames> | DerivedElement<ClientNames>,
   ][]) {
-    if (clientElement.type === Derived) {
+    if (clientElement.type === (Derived as unknown)) {
       derivedClients[key] = clientElement as DerivedElement<ClientNames>;
     } else {
       rootClients[key] = clientElement as ClientElement<ClientNames>;
     }
   }
 
-  // Recursively gather all default peers, flattening nested ones
-  const gatherDefaultPeers = (
-    clientElement: ClientElement<ClientNames>,
-    visited = new Set<ClientElement<ClientNames>>(),
-  ): Array<
-    [ClientNames, ClientElement<ClientNames> | DerivedElement<ClientNames>]
-  > => {
-    // Prevent infinite loops
-    if (visited.has(clientElement)) return [];
-    visited.add(clientElement);
-
-    const defaultPeers = getDefaultPeers(clientElement.type);
-    if (!defaultPeers) return [];
-
-    const result: Array<
-      [ClientNames, ClientElement<ClientNames> | DerivedElement<ClientNames>]
-    > = [];
-
-    for (const [key, peerElement] of Object.entries(defaultPeers) as [
-      ClientNames,
-      ClientElement<ClientNames> | DerivedElement<ClientNames>,
-    ][]) {
-      result.push([key, peerElement]);
-
-      // If this peer is a root client with its own default peers, recursively gather them
-      if (peerElement.type !== Derived<ClientNames>) {
-        const nestedPeers = gatherDefaultPeers(
-          peerElement as ClientElement<ClientNames>,
-          visited,
-        );
-        result.push(...nestedPeers);
-      }
-    }
-
-    return result;
-  };
-
-  // Apply flattened default peers for each root client
-  for (const [_clientKey, clientElement] of Object.entries(rootClients) as [
-    ClientNames,
-    ClientElement<ClientNames>,
-  ][]) {
-    const allPeers = gatherDefaultPeers(clientElement);
-
-    for (const [key, peerElement] of allPeers) {
-      // Skip if already exists (first wins)
-      if (
-        key in rootClients ||
-        key in derivedClients ||
-        baseClient[key].source !== null
-      )
-        continue;
-
-      if (peerElement.type === Derived<ClientNames>) {
-        derivedClients[key] = peerElement as DerivedElement<ClientNames>;
-      } else {
-        rootClients[key] = peerElement as ClientElement<ClientNames>;
-      }
-    }
-  }
-
   return { rootClients, derivedClients };
 }
 

package/dist/attachDefaultPeers.d.ts

@@ -1,56 +0,0 @@
-import type { ResourceElement } from "@assistant-ui/tap";
-import type { ClientElement, ClientNames } from "./types/client.js";
-import type { DerivedElement } from "./Derived.js";
-/**
- * Symbol used to store default peer clients on a resource.
- */
-declare const DEFAULT_PEERS: unique symbol;
-/**
- * Type for resources that have default peers attached.
- */
-export type ResourceWithDefaultPeers = {
-    [DEFAULT_PEERS]?: DefaultPeers;
-};
-/**
- * Default peers configuration - can be either root clients or derived clients.
- */
-export type DefaultPeers = {
-    [K in ClientNames]?: ClientElement<K> | DerivedElement<K>;
-};
-/**
- * Attaches default peer clients to a resource.
- *
- * Default peers are only applied if the scope doesn't exist:
- * - Not defined in parent context
- * - Not provided by user
- * - Not already defined by a previous resource's default peers
- *
- * First definition wins - no overriding is permitted.
- *
- * @param resource - The resource to attach default peers to
- * @param peers - The default peer clients to attach
- * @throws Error if a peer key already exists in the resource's default peers
- *
- * @example
- * ```typescript
- * const ThreadListClient = resource(({ ... }) => { ... });
- *
- * attachDefaultPeers(ThreadListClient, {
- *   // Derived default peers
- *   thread: Derived({ source: "threads", query: { type: "main" }, get: ... }),
- *   threadListItem: Derived({ ... }),
- *   composer: Derived({ getMeta: ..., get: ... }),
- *
- *   // Root default peers
- *   tools: Tools({}),
- *   modelContext: ModelContext({}),
- * });
- * ```
- */
-export declare function attachDefaultPeers<T extends (...args: any[]) => ResourceElement<any>>(resource: T, peers: DefaultPeers): void;
-/**
- * Gets the default peers attached to a resource, if any.
- */
-export declare function getDefaultPeers<T extends (...args: any[]) => ResourceElement<any>>(resource: T): DefaultPeers | undefined;
-export {};
-//# sourceMappingURL=attachDefaultPeers.d.ts.map

package/dist/attachDefaultPeers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"attachDefaultPeers.d.ts","sourceRoot":"","sources":["../src/attachDefaultPeers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,0BAAuB;AACjE,OAAO,KAAK,EAAE,cAAc,EAAE,qBAAkB;AAEhD;;GAEG;AACH,QAAA,MAAM,aAAa,eAAuC,CAAC;AAE3D;;GAEG;AACH,MAAM,MAAM,wBAAwB,GAAG;IACrC,CAAC,aAAa,CAAC,CAAC,EAAE,YAAY,CAAC;CAChC,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG;KACxB,CAAC,IAAI,WAAW,CAAC,CAAC,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC;CAC1D,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,kBAAkB,CAChC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,eAAe,CAAC,GAAG,CAAC,EAClD,QAAQ,EAAE,CAAC,EAAE,KAAK,EAAE,YAAY,GAAG,IAAI,CAaxC;AAED;;GAEG;AACH,wBAAgB,eAAe,CAC7B,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,eAAe,CAAC,GAAG,CAAC,EAClD,QAAQ,EAAE,CAAC,GAAG,YAAY,GAAG,SAAS,CAEvC"}

package/dist/attachDefaultPeers.js

@@ -1,51 +0,0 @@
-/**
- * Symbol used to store default peer clients on a resource.
- */
-const DEFAULT_PEERS = Symbol("assistant-ui.default-peers");
-/**
- * Attaches default peer clients to a resource.
- *
- * Default peers are only applied if the scope doesn't exist:
- * - Not defined in parent context
- * - Not provided by user
- * - Not already defined by a previous resource's default peers
- *
- * First definition wins - no overriding is permitted.
- *
- * @param resource - The resource to attach default peers to
- * @param peers - The default peer clients to attach
- * @throws Error if a peer key already exists in the resource's default peers
- *
- * @example
- * ```typescript
- * const ThreadListClient = resource(({ ... }) => { ... });
- *
- * attachDefaultPeers(ThreadListClient, {
- *   // Derived default peers
- *   thread: Derived({ source: "threads", query: { type: "main" }, get: ... }),
- *   threadListItem: Derived({ ... }),
- *   composer: Derived({ getMeta: ..., get: ... }),
- *
- *   // Root default peers
- *   tools: Tools({}),
- *   modelContext: ModelContext({}),
- * });
- * ```
- */
-export function attachDefaultPeers(resource, peers) {
-    const resourceWithPeers = resource;
-    const existing = resourceWithPeers[DEFAULT_PEERS] ?? {};
-    for (const key of Object.keys(peers)) {
-        if (key in existing) {
-            throw new Error(`Default peer "${key}" is already attached to this resource`);
-        }
-    }
-    resourceWithPeers[DEFAULT_PEERS] = { ...existing, ...peers };
-}
-/**
- * Gets the default peers attached to a resource, if any.
- */
-export function getDefaultPeers(resource) {
-    return resource[DEFAULT_PEERS];
-}
-//# sourceMappingURL=attachDefaultPeers.js.map

package/dist/attachDefaultPeers.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"attachDefaultPeers.js","sourceRoot":"","sources":["../src/attachDefaultPeers.ts"],"names":[],"mappings":"AAIA;;GAEG;AACH,MAAM,aAAa,GAAG,MAAM,CAAC,4BAA4B,CAAC,CAAC;AAgB3D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,UAAU,kBAAkB,CAEhC,QAAW,EAAE,KAAmB;IAChC,MAAM,iBAAiB,GAAG,QAAwC,CAAC;IACnE,MAAM,QAAQ,GAAG,iBAAiB,CAAC,aAAa,CAAC,IAAI,EAAE,CAAC;IAExD,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;QACrC,IAAI,GAAG,IAAI,QAAQ,EAAE,CAAC;YACpB,MAAM,IAAI,KAAK,CACb,iBAAiB,GAAG,wCAAwC,CAC7D,CAAC;QACJ,CAAC;IACH,CAAC;IAED,iBAAiB,CAAC,aAAa,CAAC,GAAG,EAAE,GAAG,QAAQ,EAAE,GAAG,KAAK,EAAE,CAAC;AAC/D,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,eAAe,CAE7B,QAAW;IACX,OAAQ,QAAyC,CAAC,aAAa,CAAC,CAAC;AACnE,CAAC"}