@assistant-ui/react 0.10.50 → 0.11.1

package/src/primitives/message/MessageRoot.tsx

@@ -7,33 +7,35 @@ import {
   ComponentPropsWithoutRef,
   useCallback,
 } from "react";
-import { useMessageUtilsStore } from "../../context/react/MessageContext";
+import { useAssistantApi, useAssistantState } from "../../context";
 import { useManagedRef } from "../../utils/hooks/useManagedRef";
 import { useComposedRefs } from "@radix-ui/react-compose-refs";
 
 const useIsHoveringRef = () => {
-  const messageUtilsStore = useMessageUtilsStore();
+  const api = useAssistantApi();
+  const message = useAssistantState(() => api.message());
+
   const callbackRef = useCallback(
     (el: HTMLElement) => {
-      const setIsHovering = messageUtilsStore.getState().setIsHovering;
-
       const handleMouseEnter = () => {
-        setIsHovering(true);
+        message.setIsHovering(true);
       };
       const handleMouseLeave = () => {
-        setIsHovering(false);
+        message.setIsHovering(false);
       };
 
       el.addEventListener("mouseenter", handleMouseEnter);
       el.addEventListener("mouseleave", handleMouseLeave);
 
+      if (el.matches(":hover")) message.setIsHovering(true);
+
       return () => {
         el.removeEventListener("mouseenter", handleMouseEnter);
         el.removeEventListener("mouseleave", handleMouseLeave);
-        setIsHovering(false);
+        message.setIsHovering(false);
       };
     },
-    [messageUtilsStore],
+    [message],
   );
 
   return useManagedRef(callbackRef);

package/src/primitives/messagePart/MessagePartInProgress.tsx

@@ -1,7 +1,7 @@
 "use client";
 
 import { FC, PropsWithChildren } from "react";
-import { useMessagePart } from "../../context";
+import { useAssistantState } from "../../context";
 
 export namespace MessagePartPrimitiveInProgress {
   export type Props = PropsWithChildren;
@@ -11,7 +11,9 @@ export namespace MessagePartPrimitiveInProgress {
 export const MessagePartPrimitiveInProgress: FC<
   MessagePartPrimitiveInProgress.Props
 > = ({ children }) => {
-  const isInProgress = useMessagePart((c) => c.status.type === "running");
+  const isInProgress = useAssistantState(
+    ({ part }) => part.status.type === "running",
+  );
 
   return isInProgress ? children : null;
 };

package/src/primitives/messagePart/useMessagePartFile.tsx

@@ -1,17 +1,17 @@
 "use client";
 
-import { MessagePartState } from "../../api/MessagePartRuntime";
-import { useMessagePart } from "../../context/react/MessagePartContext";
+import { MessagePartState } from "../../legacy-runtime/runtime/MessagePartRuntime";
+import { useAssistantState } from "../../context";
 import { FileMessagePart } from "../../types";
 
 export const useMessagePartFile = () => {
-  const file = useMessagePart((c) => {
-    if (c.type !== "file")
+  const file = useAssistantState(({ part }) => {
+    if (part.type !== "file")
       throw new Error(
         "MessagePartFile can only be used inside file message parts.",
       );
 
-    return c as MessagePartState & FileMessagePart;
+    return part as MessagePartState & FileMessagePart;
   });
 
   return file;

package/src/primitives/messagePart/useMessagePartImage.tsx

@@ -1,17 +1,17 @@
 "use client";
 
-import { MessagePartState } from "../../api/MessagePartRuntime";
-import { useMessagePart } from "../../context/react/MessagePartContext";
+import { MessagePartState } from "../../legacy-runtime/runtime/MessagePartRuntime";
+import { useAssistantState } from "../../context";
 import { ImageMessagePart } from "../../types";
 
 export const useMessagePartImage = () => {
-  const image = useMessagePart((c) => {
-    if (c.type !== "image")
+  const image = useAssistantState(({ part }) => {
+    if (part.type !== "image")
       throw new Error(
         "MessagePartImage can only be used inside image message parts.",
       );
 
-    return c as MessagePartState & ImageMessagePart;
+    return part as MessagePartState & ImageMessagePart;
   });
 
   return image;

package/src/primitives/messagePart/useMessagePartReasoning.tsx

@@ -1,17 +1,17 @@
 "use client";
 
-import { MessagePartState } from "../../api/MessagePartRuntime";
-import { useMessagePart } from "../../context/react/MessagePartContext";
+import { MessagePartState } from "../../legacy-runtime/runtime/MessagePartRuntime";
+import { useAssistantState } from "../../context";
 import { ReasoningMessagePart } from "../../types";
 
 export const useMessagePartReasoning = () => {
-  const text = useMessagePart((c) => {
-    if (c.type !== "reasoning")
+  const text = useAssistantState(({ part }) => {
+    if (part.type !== "reasoning")
       throw new Error(
         "MessagePartReasoning can only be used inside reasoning message parts.",
       );
 
-    return c as MessagePartState & ReasoningMessagePart;
+    return part as MessagePartState & ReasoningMessagePart;
   });
 
   return text;

package/src/primitives/messagePart/useMessagePartSource.tsx

@@ -1,17 +1,17 @@
 "use client";
 
-import { MessagePartState } from "../../api/MessagePartRuntime";
-import { useMessagePart } from "../../context/react/MessagePartContext";
+import type { MessagePartState } from "../../legacy-runtime/runtime/MessagePartRuntime";
+import { useAssistantState } from "../../context";
 import { SourceMessagePart } from "../../types";
 
 export const useMessagePartSource = () => {
-  const source = useMessagePart((c) => {
-    if (c.type !== "source")
+  const source = useAssistantState(({ part }) => {
+    if (part.type !== "source")
       throw new Error(
         "MessagePartSource can only be used inside source message parts.",
       );
 
-    return c as MessagePartState & SourceMessagePart;
+    return part as MessagePartState & SourceMessagePart;
   });
 
   return source;

package/src/primitives/messagePart/useMessagePartText.tsx

@@ -1,17 +1,17 @@
 "use client";
 
-import { MessagePartState } from "../../api/MessagePartRuntime";
-import { useMessagePart } from "../../context/react/MessagePartContext";
+import { MessagePartState } from "../../legacy-runtime/runtime/MessagePartRuntime";
+import { useAssistantState } from "../../context";
 import { TextMessagePart, ReasoningMessagePart } from "../../types";
 
 export const useMessagePartText = () => {
-  const text = useMessagePart((c) => {
-    if (c.type !== "text" && c.type !== "reasoning")
+  const text = useAssistantState(({ part }) => {
+    if (part.type !== "text" && part.type !== "reasoning")
       throw new Error(
         "MessagePartText can only be used inside text or reasoning message parts.",
       );
 
-    return c as MessagePartState & (TextMessagePart | ReasoningMessagePart);
+    return part as MessagePartState & (TextMessagePart | ReasoningMessagePart);
   });
 
   return text;

package/src/primitives/thread/ThreadEmpty.tsx

@@ -1,7 +1,7 @@
 "use client";
 
 import type { FC, PropsWithChildren } from "react";
-import { useThread } from "../../context";
+import { useAssistantState } from "../../context";
 
 export namespace ThreadPrimitiveEmpty {
   export type Props = PropsWithChildren;
@@ -10,7 +10,7 @@ export namespace ThreadPrimitiveEmpty {
 export const ThreadPrimitiveEmpty: FC<ThreadPrimitiveEmpty.Props> = ({
   children,
 }) => {
-  const empty = useThread((u) => u.messages.length === 0);
+  const empty = useAssistantState(({ thread }) => thread.messages.length === 0);
   return empty ? children : null;
 };
 

package/src/primitives/thread/ThreadIf.tsx

@@ -1,7 +1,7 @@
 "use client";
 
 import type { FC, PropsWithChildren } from "react";
-import { useThread } from "../../context";
+import { useAssistantState } from "../../context";
 import type { RequireAtLeastOne } from "../../utils/RequireAtLeastOne";
 
 type ThreadIfFilters = {
@@ -13,7 +13,7 @@ type ThreadIfFilters = {
 type UseThreadIfProps = RequireAtLeastOne<ThreadIfFilters>;
 
 const useThreadIf = (props: UseThreadIfProps) => {
-  return useThread((thread) => {
+  return useAssistantState(({ thread }) => {
     if (props.empty === true && thread.messages.length !== 0) return false;
     if (props.empty === false && thread.messages.length === 0) return false;
     if (props.running === true && !thread.isRunning) return false;

package/src/primitives/thread/ThreadMessages.tsx

@@ -1,9 +1,7 @@
 "use client";
 
 import { type ComponentType, type FC, memo, useMemo } from "react";
-import { useThread, useThreadRuntime } from "../../context/react/ThreadContext";
-import { MessageRuntimeProvider } from "../../context/providers/MessageRuntimeProvider";
-import { useEditComposer, useMessage } from "../../context";
+import { useAssistantState, MessageByIndexProvider } from "../../context";
 import { ThreadMessage as ThreadMessageType } from "../../types";
 
 export namespace ThreadPrimitiveMessages {
@@ -130,8 +128,10 @@ type ThreadMessageComponentProps = {
 const ThreadMessageComponent: FC<ThreadMessageComponentProps> = ({
   components,
 }) => {
-  const role = useMessage((m) => m.role);
-  const isEditing = useEditComposer((c) => c.isEditing);
+  const role = useAssistantState(({ message }) => message.role);
+  const isEditing = useAssistantState(
+    ({ message }) => message.composer.isEditing,
+  );
   const Component = getComponent(components, role, isEditing);
 
   return <Component />;
@@ -163,16 +163,10 @@ export namespace ThreadPrimitiveMessageByIndex {
 export const ThreadPrimitiveMessageByIndex: FC<ThreadPrimitiveMessageByIndex.Props> =
   memo(
     ({ index, components }) => {
-      const threadRuntime = useThreadRuntime();
-      const runtime = useMemo(
-        () => threadRuntime.getMesssageByIndex(index),
-        [threadRuntime, index],
-      );
-
       return (
-        <MessageRuntimeProvider runtime={runtime}>
+        <MessageByIndexProvider index={index}>
           <ThreadMessageComponent components={components} />
-        </MessageRuntimeProvider>
+        </MessageByIndexProvider>
       );
     },
     (prev, next) =>
@@ -203,7 +197,9 @@ ThreadPrimitiveMessageByIndex.displayName = "ThreadPrimitive.MessageByIndex";
 export const ThreadPrimitiveMessagesImpl: FC<ThreadPrimitiveMessages.Props> = ({
   components,
 }) => {
-  const messagesLength = useThread((t) => t.messages.length);
+  const messagesLength = useAssistantState(
+    ({ thread }) => thread.messages.length,
+  );
 
   const messageElements = useMemo(() => {
     if (messagesLength === 0) return null;

package/src/primitives/thread/ThreadSuggestion.tsx

@@ -6,8 +6,7 @@ import {
   createActionButton,
 } from "../../utils/createActionButton";
 import { useCallback } from "react";
-import { useThread } from "../../context";
-import { useThreadRuntime } from "../../context/react/ThreadContext";
+import { useAssistantState, useAssistantApi } from "../../context";
 
 const useThreadSuggestion = ({
   prompt,
@@ -17,16 +16,17 @@ const useThreadSuggestion = ({
   method?: "replace";
   autoSend?: boolean | undefined;
 }) => {
-  const threadRuntime = useThreadRuntime();
+  const api = useAssistantApi();
+  const disabled = useAssistantState(({ thread }) => thread.isDisabled);
 
-  const disabled = useThread((t) => t.isDisabled);
   const callback = useCallback(() => {
-    if (autoSend && !threadRuntime.getState().isRunning) {
-      threadRuntime.append(prompt);
+    const isRunning = api.thread().getState().isRunning;
+    if (autoSend && !isRunning) {
+      api.thread().append(prompt);
     } else {
-      threadRuntime.composer.setText(prompt);
+      api.composer().setText(prompt);
     }
-  }, [threadRuntime, autoSend, prompt]);
+  }, [api, autoSend, prompt]);
 
   if (disabled) return null;
   return callback;

package/src/primitives/thread/useThreadViewportAutoScroll.tsx

@@ -1,8 +1,8 @@
 "use client";
 
 import { useComposedRefs } from "@radix-ui/react-compose-refs";
-import { RefCallback, useCallback, useEffect, useRef } from "react";
-import { useThreadRuntime } from "../../context/react/ThreadContext";
+import { RefCallback, useCallback, useRef } from "react";
+import { useAssistantEvent } from "../../context";
 import { useOnResizeContent } from "../../utils/hooks/useOnResizeContent";
 import { useOnScrollToBottom } from "../../utils/hooks/useOnScrollToBottom";
 import { useManagedRef } from "../../utils/hooks/useManagedRef";
@@ -87,10 +87,7 @@ export const useThreadViewportAutoScroll = <TElement extends HTMLElement>({
   });
 
   // autoscroll on run start
-  const threadRuntime = useThreadRuntime();
-  useEffect(() => {
-    return threadRuntime.unstable_on("run-start", () => scrollToBottom("auto"));
-  }, [scrollToBottom, threadRuntime]);
+  useAssistantEvent("thread.run-start", () => scrollToBottom("auto"));
 
   const autoScrollRef = useComposedRefs<TElement>(resizeRef, scrollRef, divRef);
   return autoScrollRef as RefCallback<TElement>;

package/src/primitives/threadList/ThreadListItems.tsx

@@ -1,8 +1,10 @@
 "use client";
 
 import { ComponentType, FC, memo, useMemo } from "react";
-import { ThreadListItemRuntimeProvider } from "../../context/providers/ThreadListItemRuntimeProvider";
-import { useAssistantRuntime, useThreadList } from "../../context";
+import {
+  ThreadListItemByIndexProvider,
+  useAssistantState,
+} from "../../context";
 
 export namespace ThreadListPrimitiveItems {
   export type Props = {
@@ -40,21 +42,12 @@ export namespace ThreadListPrimitiveItemByIndex {
 export const ThreadListPrimitiveItemByIndex: FC<ThreadListPrimitiveItemByIndex.Props> =
   memo(
     ({ index, archived = false, components }) => {
-      const assistantRuntime = useAssistantRuntime();
-      const runtime = useMemo(
-        () =>
-          archived
-            ? assistantRuntime.threads.getArchivedItemByIndex(index)
-            : assistantRuntime.threads.getItemByIndex(index),
-        [assistantRuntime, index, archived],
-      );
-
       const ThreadListItemComponent = components.ThreadListItem;
 
       return (
-        <ThreadListItemRuntimeProvider runtime={runtime}>
+        <ThreadListItemByIndexProvider index={index} archived={archived}>
           <ThreadListItemComponent />
-        </ThreadListItemRuntimeProvider>
+        </ThreadListItemByIndexProvider>
       );
     },
     (prev, next) =>
@@ -69,8 +62,8 @@ export const ThreadListPrimitiveItems: FC<ThreadListPrimitiveItems.Props> = ({
   archived = false,
   components,
 }) => {
-  const contentLength = useThreadList((s) =>
-    archived ? s.archivedThreads.length : s.threads.length,
+  const contentLength = useAssistantState(({ threads }) =>
+    archived ? threads.archivedThreadIds.length : threads.threadIds.length,
   );
 
   const listElements = useMemo(() => {

package/src/primitives/threadList/ThreadListNew.tsx

@@ -4,29 +4,25 @@ import {
   ActionButtonElement,
   ActionButtonProps,
 } from "../../utils/createActionButton";
-import { useAssistantRuntime, useThreadList } from "../../context";
 import { forwardRef } from "react";
 import { Primitive } from "@radix-ui/react-primitive";
 import { composeEventHandlers } from "@radix-ui/primitive";
-
-const useThreadListNew = () => {
-  const runtime = useAssistantRuntime();
-  return () => {
-    runtime.switchToNewThread();
-  };
-};
+import { useAssistantState, useAssistantApi } from "../../context";
 
 export namespace ThreadListPrimitiveNew {
   export type Element = ActionButtonElement;
-  export type Props = ActionButtonProps<typeof useThreadListNew>;
+  export type Props = ActionButtonProps<() => void>;
 }
 
 export const ThreadListPrimitiveNew = forwardRef<
   ThreadListPrimitiveNew.Element,
   ThreadListPrimitiveNew.Props
 >(({ onClick, disabled, ...props }, forwardedRef) => {
-  const isMain = useThreadList((t) => t.newThread === t.mainThreadId);
-  const callback = useThreadListNew();
+  const isMain = useAssistantState(
+    ({ threads }) => threads.newThreadId === threads.mainThreadId,
+  );
+
+  const api = useAssistantApi();
 
   return (
     <Primitive.button
@@ -34,9 +30,9 @@ export const ThreadListPrimitiveNew = forwardRef<
       {...(isMain ? { "data-active": "true", "aria-current": "true" } : null)}
       {...props}
       ref={forwardedRef}
-      disabled={disabled || !callback}
+      disabled={disabled}
       onClick={composeEventHandlers(onClick, () => {
-        callback?.();
+        api.threads().switchToNewThread();
       })}
     />
   );

package/src/primitives/threadListItem/ThreadListItemArchive.ts

@@ -5,14 +5,14 @@ import {
   ActionButtonProps,
   createActionButton,
 } from "../../utils/createActionButton";
-import { useThreadListItemRuntime } from "../../context/react/ThreadListItemContext";
+import { useAssistantApi } from "../../context";
 import { useCallback } from "react";
 
 const useThreadListItemArchive = () => {
-  const runtime = useThreadListItemRuntime();
+  const api = useAssistantApi();
   return useCallback(() => {
-    runtime.archive();
-  }, [runtime]);
+    api.threadListItem().archive();
+  }, [api]);
 };
 
 export namespace ThreadListItemPrimitiveArchive {

package/src/primitives/threadListItem/ThreadListItemDelete.ts

@@ -5,13 +5,14 @@ import {
   ActionButtonProps,
   createActionButton,
 } from "../../utils/createActionButton";
-import { useThreadListItemRuntime } from "../../context/react/ThreadListItemContext";
+import { useAssistantApi } from "../../context";
+import { useCallback } from "react";
 
 const useThreadListItemDelete = () => {
-  const runtime = useThreadListItemRuntime();
-  return () => {
-    runtime.delete();
-  };
+  const api = useAssistantApi();
+  return useCallback(() => {
+    api.threadListItem().delete();
+  }, [api]);
 };
 
 export namespace ThreadListItemPrimitiveDelete {

package/src/primitives/threadListItem/ThreadListItemRoot.tsx

@@ -2,7 +2,7 @@
 
 import { Primitive } from "@radix-ui/react-primitive";
 import { type ComponentRef, forwardRef, ComponentPropsWithoutRef } from "react";
-import { useThreadListItem } from "../../context/react/ThreadListItemContext";
+import { useAssistantState } from "../../context";
 
 type PrimitiveDivProps = ComponentPropsWithoutRef<typeof Primitive.div>;
 
@@ -15,7 +15,9 @@ export const ThreadListItemPrimitiveRoot = forwardRef<
   ThreadListItemPrimitiveRoot.Element,
   ThreadListItemPrimitiveRoot.Props
 >((props, ref) => {
-  const isMain = useThreadListItem((t) => t.isMain);
+  const isMain = useAssistantState(
+    ({ threads, threadListItem }) => threads.mainThreadId === threadListItem.id,
+  );
 
   return (
     <Primitive.div

package/src/primitives/threadListItem/ThreadListItemTitle.tsx

@@ -1,7 +1,7 @@
 "use client";
 
 import type { FC, ReactNode } from "react";
-import { useThreadListItem } from "../../context/react/ThreadListItemContext";
+import { useAssistantState } from "../../context";
 
 export namespace ThreadListItemPrimitiveTitle {
   export type Props = {
@@ -12,7 +12,7 @@ export namespace ThreadListItemPrimitiveTitle {
 export const ThreadListItemPrimitiveTitle: FC<
   ThreadListItemPrimitiveTitle.Props
 > = ({ fallback }) => {
-  const title = useThreadListItem((t) => t.title);
+  const title = useAssistantState(({ threadListItem }) => threadListItem.title);
   return <>{title || fallback}</>;
 };
 

package/src/primitives/threadListItem/ThreadListItemTrigger.ts

@@ -5,13 +5,14 @@ import {
   ActionButtonProps,
   createActionButton,
 } from "../../utils/createActionButton";
-import { useThreadListItemRuntime } from "../../context/react/ThreadListItemContext";
+import { useAssistantApi } from "../../context";
+import { useCallback } from "react";
 
 const useThreadListItemTrigger = () => {
-  const runtime = useThreadListItemRuntime();
-  return () => {
-    runtime.switchTo();
-  };
+  const api = useAssistantApi();
+  return useCallback(() => {
+    api.threadListItem().switchTo();
+  }, [api]);
 };
 
 export namespace ThreadListItemPrimitiveTrigger {

package/src/primitives/threadListItem/ThreadListItemUnarchive.ts

@@ -5,13 +5,14 @@ import {
   ActionButtonProps,
   createActionButton,
 } from "../../utils/createActionButton";
-import { useThreadListItemRuntime } from "../../context/react/ThreadListItemContext";
+import { useAssistantApi } from "../../context";
+import { useCallback } from "react";
 
 const useThreadListItemUnarchive = () => {
-  const runtime = useThreadListItemRuntime();
-  return () => {
-    runtime.unarchive();
-  };
+  const api = useAssistantApi();
+  return useCallback(() => {
+    api.threadListItem().unarchive();
+  }, [api]);
 };
 
 export namespace ThreadListItemPrimitiveUnarchive {

package/src/tests/MessageRepository.test.ts

@@ -2,9 +2,9 @@ import { describe, it, expect, beforeEach, vi, afterEach } from "vitest";
 import {
   MessageRepository,
   ExportedMessageRepository,
-} from "../runtimes/utils/MessageRepository";
+} from "../legacy-runtime/runtime-cores/utils/MessageRepository";
 import type { ThreadMessage, TextMessagePart } from "../types/AssistantTypes";
-import { ThreadMessageLike } from "../runtimes";
+import type { ThreadMessageLike } from "../legacy-runtime/runtime-cores";
 
 // Mock generateId and generateOptimisticId to make tests deterministic
 const mockGenerateId = vi.fn();

package/src/types/EventTypes.ts

@@ -0,0 +1,92 @@
+export type EventSource<
+  T extends keyof AssistantEvents = keyof AssistantEvents,
+> = T extends `${infer Source}.${string}` ? Source : never;
+
+type ScopeConfig = {
+  composer: "thread" | "message";
+  thread: never;
+  "thread-list-item": never;
+};
+
+export type SourceByScope<
+  TScope extends AssistantEventScope<keyof AssistantEvents>,
+> =
+  | (TScope extends "*" ? EventSource : never)
+  | (TScope extends keyof ScopeConfig ? TScope : never)
+  | {
+      [K in keyof ScopeConfig]: TScope extends ScopeConfig[K] ? K : never;
+    }[keyof ScopeConfig];
+
+export type AssistantEventScope<TEvent extends keyof AssistantEvents> =
+  | "*"
+  | EventSource<TEvent>
+  | ScopeConfig[EventSource<TEvent>];
+
+export type AssistantEventSelector<TEvent extends keyof AssistantEvents> =
+  | TEvent
+  | {
+      scope: AssistantEventScope<TEvent>;
+      event: TEvent;
+    };
+
+export type AssistantEvents = {
+  // Thread events (from ThreadRuntimeEventType)
+  "thread.run-start": {
+    threadId: string;
+  };
+  "thread.run-end": {
+    threadId: string;
+  };
+  "thread.initialize": {
+    threadId: string;
+  };
+  "thread.model-context-update": {
+    threadId: string;
+  };
+
+  // Composer events (from ComposerRuntimeEventType)
+  "composer.send": {
+    threadId: string;
+    messageId?: string;
+  };
+  "composer.attachment-add": {
+    threadId: string;
+    messageId?: string;
+  };
+
+  // Thread list item events (from ThreadListItemEventType)
+  "thread-list-item.switched-to": {
+    threadId: string;
+  };
+  "thread-list-item.switched-away": {
+    threadId: string;
+  };
+};
+
+export const normalizeEventSelector = <TEvent extends keyof AssistantEvents>(
+  selector: AssistantEventSelector<TEvent>,
+) => {
+  if (typeof selector === "string") {
+    const source = selector.split(".")[0] as AssistantEventScope<TEvent>;
+    return {
+      scope: source,
+      event: selector,
+    };
+  }
+
+  return {
+    scope: selector.scope,
+    event: selector.event,
+  };
+};
+
+export const checkEventScope = <
+  TEvent extends keyof AssistantEvents,
+  TExpectedScope extends AssistantEventScope<keyof AssistantEvents>,
+>(
+  expectedScope: TExpectedScope,
+  scope: AssistantEventScope<TEvent>,
+  _event: TEvent,
+): _event is Extract<TEvent, `${SourceByScope<TExpectedScope>}.${string}`> => {
+  return scope === expectedScope;
+};