@assistant-ui/react 0.15.20 → 0.15.21

package/dist/unstable/useSlashCommandAdapter.d.ts

@@ -1,14 +1,14 @@
 import { Unstable_IconComponent } from "./useMentionAdapter.js";
 import { Unstable_TriggerAdapter, Unstable_TriggerItem } from "@assistant-ui/core";
 //#region src/unstable/useSlashCommandAdapter.d.ts
-type Unstable_SlashCommand = {
+export type Unstable_SlashCommand = {
   readonly id: string;
   readonly label?: string | undefined;
   readonly description?: string | undefined;
   readonly icon?: string | undefined;
   readonly execute: () => void;
 };
-type Unstable_UseSlashCommandAdapterOptions = {
+export type Unstable_UseSlashCommandAdapterOptions = {
   readonly commands: readonly Unstable_SlashCommand[];
   /** Strip the trigger text from the composer after executing. @default false */
   readonly removeOnExecute?: boolean | undefined;
@@ -17,7 +17,7 @@ type Unstable_UseSlashCommandAdapterOptions = {
   /** Fallback icon when no entry in `iconMap` matches. */
   readonly fallbackIcon?: Unstable_IconComponent;
 };
-type Unstable_SlashCommandAction = {
+export type Unstable_SlashCommandAction = {
   readonly onExecute: (item: Unstable_TriggerItem) => void;
   readonly removeOnExecute?: boolean | undefined;
 };
@@ -41,12 +41,11 @@ type Unstable_SlashCommandAction = {
  * <ComposerTriggerPopover char="/" {...slash} />
  * ```
  */
-declare function unstable_useSlashCommandAdapter(options: Unstable_UseSlashCommandAdapterOptions): {
+export declare function unstable_useSlashCommandAdapter(options: Unstable_UseSlashCommandAdapterOptions): {
   adapter: Unstable_TriggerAdapter;
   action: Unstable_SlashCommandAction;
   iconMap?: Record<string, Unstable_IconComponent>;
   fallbackIcon?: Unstable_IconComponent;
 };
 //#endregion
-export { Unstable_SlashCommand, Unstable_SlashCommandAction, Unstable_UseSlashCommandAdapterOptions, unstable_useSlashCommandAdapter };
 //# sourceMappingURL=useSlashCommandAdapter.d.ts.map

package/dist/unstable/useSlashCommandAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useSlashCommandAdapter.d.ts","names":[],"sources":["../../src/unstable/useSlashCommandAdapter.ts"],"mappings":";;;KAUY;WACD;WACA;WACA;WACA;WACA;;KAGC;WACD,mBAAmB;;WAEnB;;WAEA,UAAU,eAAe;;WAEzB,eAAe;;KAGd;WACD,YAAY,MAAM;WAClB;;;;;;;;;;;;;;;;;;;;;;iBAuBK,gCACd,SAAS;EAET,SAAS;EACT,QAAQ;EACR,UAAU,eAAe;EACzB,eAAe"}
+{"version":3,"file":"useSlashCommandAdapter.d.ts","names":[],"sources":["../../src/unstable/useSlashCommandAdapter.ts"],"mappings":";;;YAUY;WACD;WACA;WACA;WACA;WACA;;YAGC;WACD,mBAAmB;;WAEnB;;WAEA,UAAU,eAAe;;WAEzB,eAAe;;YAGd;WACD,YAAY,MAAM;WAClB;;;;;;;;;;;;;;;;;;;;;;wBAuBK,gCACd,SAAS;EAET,SAAS;EACT,QAAQ;EACR,UAAU,eAAe;EACzB,eAAe"}

package/dist/unstable/webmcp/WebMcpRegistrationResource.d.ts

@@ -1,14 +1,13 @@
 import { WebMcpHost } from "./webmcp-host.js";
 import { Tool } from "assistant-stream";
 //#region src/unstable/webmcp/WebMcpRegistrationResource.d.ts
-type WebMcpRegistrationProps = {
+export type WebMcpRegistrationProps = {
   host: WebMcpHost;
   name: string;
   /** Re-registers when it changes; an execute-only edit reads through instead. */
   signature: string;
   tool: Tool<any, any>;
 };
-declare const WebMcpRegistrationResource: import("@assistant-ui/tap").Resource<string | null, [WebMcpRegistrationProps]>;
+export declare const WebMcpRegistrationResource: import("@assistant-ui/tap").Resource<string | null, [WebMcpRegistrationProps]>;
 //#endregion
-export { WebMcpRegistrationProps, WebMcpRegistrationResource };
 //# sourceMappingURL=WebMcpRegistrationResource.d.ts.map

package/dist/unstable/webmcp/WebMcpRegistrationResource.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WebMcpRegistrationResource.d.ts","names":[],"sources":["../../../src/unstable/webmcp/WebMcpRegistrationResource.ts"],"mappings":";;;KAMY;EACV,MAAM;EACN;;EAEA;EACA,MAAM;;cAgFK,wDAA0B,yBAAA"}
+{"version":3,"file":"WebMcpRegistrationResource.d.ts","names":[],"sources":["../../../src/unstable/webmcp/WebMcpRegistrationResource.ts"],"mappings":";;;YAMY;EACV,MAAM;EACN;;EAEA;EACA,MAAM;;qBAgFK,wDAA0B,yBAAA"}

package/dist/unstable/webmcp/convertTools.d.ts

@@ -8,14 +8,13 @@ import { Tool } from "assistant-stream";
  * type-less form from a backend or human tool. A `filter` replaces this, so
  * pass it through to narrow the default set rather than widen it.
  */
-declare const defaultWebMcpFilter: (_name: string, tool: Tool<any, any>) => boolean;
-declare const toWebMcpInputSchema: (tool: Tool<any, any>) => unknown;
-declare const toMcpContent: (result: unknown, options: {
+export declare const defaultWebMcpFilter: (_name: string, tool: Tool<any, any>) => boolean;
+export declare const toWebMcpInputSchema: (tool: Tool<any, any>) => unknown;
+export declare const toMcpContent: (result: unknown, options: {
   tool: Tool<any, any>;
   toolCallId: string;
   args: Record<string, unknown>;
 }) => Promise<WebMcpCallToolResult>;
-declare const toWebMcpTool: (name: string, getTool: () => Tool<any, any>, lifecycleSignal?: AbortSignal) => WebMcpToolDescriptor;
+export declare const toWebMcpTool: (name: string, getTool: () => Tool<any, any>, lifecycleSignal?: AbortSignal) => WebMcpToolDescriptor;
 //#endregion
-export { defaultWebMcpFilter, toMcpContent, toWebMcpInputSchema, toWebMcpTool };
 //# sourceMappingURL=convertTools.d.ts.map

package/dist/unstable/webmcp/convertTools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"convertTools.d.ts","names":[],"sources":["../../../src/unstable/webmcp/convertTools.ts"],"mappings":";;;;;;;;;;cAoBa,sBACX,eACA,MAAM;cAMK,sBAAuB,MAAM;cA2C7B,eACX,iBACA;EACE,MAAM;EACN;EACA,MAAM;MAEP,QAAQ;cAwGE,eACX,cACA,eAAe,gBACf,kBAAkB,gBACjB"}
+{"version":3,"file":"convertTools.d.ts","names":[],"sources":["../../../src/unstable/webmcp/convertTools.ts"],"mappings":";;;;;;;;;;qBAoBa,sBACX,eACA,MAAM;qBAMK,sBAAuB,MAAM;qBA2C7B,eACX,iBACA;EACE,MAAM;EACN;EACA,MAAM;MAEP,QAAQ;qBAwGE,eACX,cACA,eAAe,gBACf,kBAAkB,gBACjB"}

package/dist/unstable/webmcp/useWebMcpProvider.d.ts

@@ -1,9 +1,9 @@
 import { Tool } from "assistant-stream";
 //#region src/unstable/webmcp/useWebMcpProvider.d.ts
-type Unstable_WebMcpProviderOptions = {
+export type Unstable_WebMcpProviderOptions = {
   filter?: (name: string, tool: Tool<any, any>) => boolean;
 };
-type Unstable_WebMcpProviderResult = {
+export type Unstable_WebMcpProviderResult = {
   status: "unsupported" | "active";
   registeredToolNames: readonly string[];
 };
@@ -15,7 +15,6 @@ type Unstable_WebMcpProviderResult = {
  * `document.modelContext` (or `navigator.modelContext`), and the sorted names
  * of the tools currently registered with the host.
  */
-declare const unstable_useWebMcpProvider: (options?: Unstable_WebMcpProviderOptions) => Unstable_WebMcpProviderResult;
+export declare const unstable_useWebMcpProvider: (options?: Unstable_WebMcpProviderOptions) => Unstable_WebMcpProviderResult;
 //#endregion
-export { Unstable_WebMcpProviderOptions, Unstable_WebMcpProviderResult, unstable_useWebMcpProvider };
 //# sourceMappingURL=useWebMcpProvider.d.ts.map

package/dist/unstable/webmcp/useWebMcpProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useWebMcpProvider.d.ts","names":[],"sources":["../../../src/unstable/webmcp/useWebMcpProvider.ts"],"mappings":";;KAeY;EACV,UAAU,cAAc,MAAM;;KAGpB;EACV;EACA;;;;;;;;;;cAqGW,6BACX,UAAS,mCACR"}
+{"version":3,"file":"useWebMcpProvider.d.ts","names":[],"sources":["../../../src/unstable/webmcp/useWebMcpProvider.ts"],"mappings":";;YAeY;EACV,UAAU,cAAc,MAAM;;YAGpB;EACV;EACA;;;;;;;;;;qBAqGW,6BACX,UAAS,mCACR"}

package/dist/unstable/webmcp/webmcp-host.d.ts

@@ -1,5 +1,5 @@
 //#region src/unstable/webmcp/webmcp-host.d.ts
-type WebMcpContent = {
+export type WebMcpContent = {
   type: "text";
   text: string;
 } | {
@@ -7,11 +7,11 @@ type WebMcpContent = {
   data: string;
   mimeType: string;
 };
-type WebMcpCallToolResult = {
+export type WebMcpCallToolResult = {
   content: WebMcpContent[];
   isError?: boolean;
 };
-type WebMcpToolDescriptor = {
+export type WebMcpToolDescriptor = {
   name: string;
   description: string;
   inputSchema: unknown;
@@ -19,7 +19,7 @@ type WebMcpToolDescriptor = {
     signal?: AbortSignal;
   }) => Promise<WebMcpCallToolResult>;
 };
-type WebMcpModelContext = {
+export type WebMcpModelContext = {
   /**
    * Aborting `options.signal` is what unregisters the tool. The explainer
    * defines no other removal method, and a name-keyed one could not be used
@@ -29,11 +29,10 @@ type WebMcpModelContext = {
     signal?: AbortSignal;
   }): Promise<void> | void;
 };
-type WebMcpHost = {
+export type WebMcpHost = {
   available: boolean;
   registerTool(def: WebMcpToolDescriptor, onError?: (error: unknown) => void): () => void;
 };
-declare const getDefaultWebMcpHost: () => WebMcpHost;
+export declare const getDefaultWebMcpHost: () => WebMcpHost;
 //#endregion
-export { WebMcpCallToolResult, WebMcpContent, WebMcpHost, WebMcpModelContext, WebMcpToolDescriptor, getDefaultWebMcpHost };
 //# sourceMappingURL=webmcp-host.d.ts.map

package/dist/unstable/webmcp/webmcp-host.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"webmcp-host.d.ts","names":[],"sources":["../../../src/unstable/webmcp/webmcp-host.ts"],"mappings":";KAAY;EACN;EAAc;;EACd;EAAe;EAAc;;KAEvB;EACV,SAAS;EACT;;KAGU;EACV;EACA;EACA;EACA,UACE,eACA;IAAY,SAAS;QAClB,QAAQ;;KAGH;;;;;;EAMV,aACE,MAAM,sBACN;IAAY,SAAS;MACpB;;KAGO;EACV;EACA,aACE,KAAK,sBACL,WAAW;;cAsCF,4BAA2B"}
+{"version":3,"file":"webmcp-host.d.ts","names":[],"sources":["../../../src/unstable/webmcp/webmcp-host.ts"],"mappings":";YAAY;EACN;EAAc;;EACd;EAAe;EAAc;;YAEvB;EACV,SAAS;EACT;;YAGU;EACV;EACA;EACA;EACA,UACE,eACA;IAAY,SAAS;QAClB,QAAQ;;YAGH;;;;;;EAMV,aACE,MAAM,sBACN;IAAY,SAAS;MACpB;;YAGO;EACV;EACA,aACE,KAAK,sBACL,WAAW;;qBAsCF,4BAA2B"}

package/dist/utils/RequireAtLeastOne.d.ts

@@ -1,5 +1,4 @@
 //#region src/utils/RequireAtLeastOne.d.ts
-type RequireAtLeastOne<T, Keys extends keyof T = keyof T> = Pick<T, Exclude<keyof T, Keys>> & { [K in Keys]-?: Required<Pick<T, K>> & Partial<Pick<T, Exclude<Keys, K>>>; }[Keys];
+export type RequireAtLeastOne<T, Keys extends keyof T = keyof T> = Pick<T, Exclude<keyof T, Keys>> & { [K in Keys]-?: Required<Pick<T, K>> & Partial<Pick<T, Exclude<Keys, K>>>; }[Keys];
 //#endregion
-export { RequireAtLeastOne };
 //# sourceMappingURL=RequireAtLeastOne.d.ts.map

package/dist/utils/RequireAtLeastOne.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RequireAtLeastOne.d.ts","names":[],"sources":["../../src/utils/RequireAtLeastOne.ts"],"mappings":";KAAY,kBAAkB,GAAG,mBAAmB,UAAU,KAAK,KACjE,GACA,cAAc,GAAG,YAGd,KAAK,SAAS,SAAS,KAAK,GAAG,MAAM,QAAQ,KAAK,GAAG,QAAQ,MAAM,QACpE"}
+{"version":3,"file":"RequireAtLeastOne.d.ts","names":[],"sources":["../../src/utils/RequireAtLeastOne.ts"],"mappings":";YAAY,kBAAkB,GAAG,mBAAmB,UAAU,KAAK,KACjE,GACA,cAAc,GAAG,YAGd,KAAK,SAAS,SAAS,KAAK,GAAG,MAAM,QAAQ,KAAK,GAAG,QAAQ,MAAM,QACpE"}

package/dist/utils/createActionButton.d.ts

@@ -3,13 +3,12 @@ import { ComponentPropsWithoutRef, ComponentRef, MouseEventHandler } from "react
 //#region src/utils/createActionButton.d.ts
 type ActionButtonCallback<TProps> = (props: TProps) => MouseEventHandler<HTMLButtonElement> | null;
 type PrimitiveButtonProps = ComponentPropsWithoutRef<typeof Primitive.button>;
-type ActionButtonProps<THook> = PrimitiveButtonProps & (THook extends ((props: infer TProps) => unknown) ? TProps : never);
-type ActionButtonElement = ComponentRef<typeof Primitive.button>;
-declare const createActionButton: <TProps>(displayName: string, useActionButton: ActionButtonCallback<TProps>, forwardProps?: (keyof NonNullable<TProps>)[]) => import("react").ForwardRefExoticComponent<import("react").PropsWithoutRef<Omit<Omit<import("react").ClassAttributes<HTMLButtonElement> & import("react").ButtonHTMLAttributes<HTMLButtonElement> & {
+export type ActionButtonProps<THook> = PrimitiveButtonProps & (THook extends ((props: infer TProps) => unknown) ? TProps : never);
+export type ActionButtonElement = ComponentRef<typeof Primitive.button>;
+export declare const createActionButton: <TProps>(displayName: string, useActionButton: ActionButtonCallback<TProps>, forwardProps?: (keyof NonNullable<TProps>)[]) => import("react").ForwardRefExoticComponent<import("react").PropsWithoutRef<Omit<Omit<import("react").ClassAttributes<HTMLButtonElement> & import("react").ButtonHTMLAttributes<HTMLButtonElement> & {
   asChild?: boolean;
 }, "ref"> & {
   render?: import("react").ReactElement | undefined;
 } & import("react").RefAttributes<HTMLButtonElement>, "ref"> & TProps> & import("react").RefAttributes<HTMLButtonElement>>;
 //#endregion
-export { ActionButtonElement, ActionButtonProps, createActionButton };
 //# sourceMappingURL=createActionButton.d.ts.map

package/dist/utils/createActionButton.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createActionButton.d.ts","names":[],"sources":["../../src/utils/createActionButton.tsx"],"mappings":";;;KASK,qBAAqB,WACxB,OAAO,WACJ,kBAAkB;KAElB,uBAAuB,gCAAgC,UAAU;KAE1D,kBAAkB,SAAS,wBACpC,gBAAe,aAAa,sBAAqB;KAExC,sBAAsB,oBAAoB,UAAU;cAEnD,qBAAsB,QACjC,qBACA,iBAAiB,qBAAqB,SACtC,sBAAqB,YAAY,+BAAe,0CAAA,gBAAA,KAAA,qBAAA,gBAAA,qCAAA,qBAAA;;;;oBAgCjD,cAAA,6BAAA,0BAAA,cAAA"}
+{"version":3,"file":"createActionButton.d.ts","names":[],"sources":["../../src/utils/createActionButton.tsx"],"mappings":";;;KASK,qBAAqB,WACxB,OAAO,WACJ,kBAAkB;KAElB,uBAAuB,gCAAgC,UAAU;YAE1D,kBAAkB,SAAS,wBACpC,gBAAe,aAAa,sBAAqB;YAExC,sBAAsB,oBAAoB,UAAU;qBAEnD,qBAAsB,QACjC,qBACA,iBAAiB,qBAAqB,SACtC,sBAAqB,YAAY,+BAAe,0CAAA,gBAAA,KAAA,qBAAA,gBAAA,qCAAA,qBAAA;;;;oBAgCjD,cAAA,6BAAA,0BAAA,cAAA"}

package/dist/utils/getSelectionMessageId.d.ts

@@ -1,5 +1,4 @@
 //#region src/utils/getSelectionMessageId.d.ts
-declare const getSelectionMessageId: (selection: Selection) => string | null;
+export declare const getSelectionMessageId: (selection: Selection) => string | null;
 //#endregion
-export { getSelectionMessageId };
 //# sourceMappingURL=getSelectionMessageId.d.ts.map

package/dist/utils/getSelectionMessageId.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getSelectionMessageId.d.ts","names":[],"sources":["../../src/utils/getSelectionMessageId.ts"],"mappings":";cAwDa,wBAAyB,WAAW"}
+{"version":3,"file":"getSelectionMessageId.d.ts","names":[],"sources":["../../src/utils/getSelectionMessageId.ts"],"mappings":";qBAwDa,wBAAyB,WAAW"}

package/dist/utils/hooks/useManagedRef.d.ts

@@ -1,5 +1,4 @@
 //#region src/utils/hooks/useManagedRef.d.ts
-declare const useManagedRef: <TNode>(callback: (node: TNode) => (() => void) | undefined) => (el: TNode | null) => void;
+export declare const useManagedRef: <TNode>(callback: (node: TNode) => (() => void) | undefined) => (el: TNode | null) => void;
 //#endregion
-export { useManagedRef };
 //# sourceMappingURL=useManagedRef.d.ts.map

package/dist/utils/hooks/useManagedRef.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useManagedRef.d.ts","names":[],"sources":["../../../src/utils/hooks/useManagedRef.ts"],"mappings":";cAEa,gBAAiB,OAC5B,WAAW,MAAM,wCAAkC,IAK5C"}
+{"version":3,"file":"useManagedRef.d.ts","names":[],"sources":["../../../src/utils/hooks/useManagedRef.ts"],"mappings":";qBAEa,gBAAiB,OAC5B,WAAW,MAAM,wCAAkC,IAK5C"}

package/dist/utils/hooks/useMediaQuery.d.ts

@@ -1,5 +1,4 @@
 //#region src/utils/hooks/useMediaQuery.d.ts
-declare const useMediaQuery: (query: string | null) => boolean;
+export declare const useMediaQuery: (query: string | null) => boolean;
 //#endregion
-export { useMediaQuery };
 //# sourceMappingURL=useMediaQuery.d.ts.map

package/dist/utils/hooks/useMediaQuery.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useMediaQuery.d.ts","names":[],"sources":["../../../src/utils/hooks/useMediaQuery.ts"],"mappings":";cAOa,gBAAiB"}
+{"version":3,"file":"useMediaQuery.d.ts","names":[],"sources":["../../../src/utils/hooks/useMediaQuery.ts"],"mappings":";qBAOa,gBAAiB"}

package/dist/utils/hooks/useOnResizeContent.d.ts

@@ -1,5 +1,4 @@
 //#region src/utils/hooks/useOnResizeContent.d.ts
-declare const useOnResizeContent: (callback: () => void) => (el: HTMLElement | null) => void;
+export declare const useOnResizeContent: (callback: () => void) => (el: HTMLElement | null) => void;
 //#endregion
-export { useOnResizeContent };
 //# sourceMappingURL=useOnResizeContent.d.ts.map

package/dist/utils/hooks/useOnResizeContent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useOnResizeContent.d.ts","names":[],"sources":["../../../src/utils/hooks/useOnResizeContent.ts"],"mappings":";cAIa,qBAAsB,0BAAoB,IAAA"}
+{"version":3,"file":"useOnResizeContent.d.ts","names":[],"sources":["../../../src/utils/hooks/useOnResizeContent.ts"],"mappings":";qBAIa,qBAAsB,0BAAoB,IAAA"}

package/dist/utils/hooks/useOnScrollToBottom.d.ts

@@ -1,7 +1,6 @@
 //#region src/utils/hooks/useOnScrollToBottom.d.ts
-declare const useOnScrollToBottom: (callback: (config: {
+export declare const useOnScrollToBottom: (callback: (config: {
   behavior: ScrollBehavior;
 }) => void) => void;
 //#endregion
-export { useOnScrollToBottom };
 //# sourceMappingURL=useOnScrollToBottom.d.ts.map

package/dist/utils/hooks/useOnScrollToBottom.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useOnScrollToBottom.d.ts","names":[],"sources":["../../../src/utils/hooks/useOnScrollToBottom.ts"],"mappings":";cAMa,sBACX,WAAW;EAAU,UAAU"}
+{"version":3,"file":"useOnScrollToBottom.d.ts","names":[],"sources":["../../../src/utils/hooks/useOnScrollToBottom.ts"],"mappings":";qBAMa,sBACX,WAAW;EAAU,UAAU"}

package/dist/utils/hooks/useSizeHandle.d.ts

@@ -8,7 +8,6 @@ import { SizeHandle } from "../../context/stores/ThreadViewport.js";
  * @param getHeight - Optional function to compute height (defaults to el.offsetHeight)
  * @returns A ref callback to attach to the element
  */
-declare const useSizeHandle: (register: (() => SizeHandle) | null | undefined, getHeight?: (el: HTMLElement) => number) => (el: HTMLElement | null) => void;
+export declare const useSizeHandle: (register: (() => SizeHandle) | null | undefined, getHeight?: (el: HTMLElement) => number) => (el: HTMLElement | null) => void;
 //#endregion
-export { useSizeHandle };
 //# sourceMappingURL=useSizeHandle.d.ts.map

package/dist/utils/hooks/useSizeHandle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useSizeHandle.d.ts","names":[],"sources":["../../../src/utils/hooks/useSizeHandle.ts"],"mappings":";;;;;;;;;;cAca,gBACX,iBAAiB,gCACjB,aAAa,IAAI,4BAAsB,IAAA"}
+{"version":3,"file":"useSizeHandle.d.ts","names":[],"sources":["../../../src/utils/hooks/useSizeHandle.ts"],"mappings":";;;;;;;;;;qBAca,gBACX,iBAAiB,gCACjB,aAAa,IAAI,4BAAsB,IAAA"}

package/dist/utils/smooth/SmoothContext.d.ts

@@ -1,9 +1,9 @@
 import { ReadonlyStore } from "../../context/ReadonlyStore.js";
 import { ComponentType, FC, PropsWithChildren } from "react";
 //#region src/utils/smooth/SmoothContext.d.ts
-declare const SmoothContextProvider: FC<PropsWithChildren>;
-declare const withSmoothContextProvider: <C extends ComponentType<any>>(Component: C) => C;
-declare const useSmoothStatus: {
+export declare const SmoothContextProvider: FC<PropsWithChildren>;
+export declare const withSmoothContextProvider: <C extends ComponentType<any>>(Component: C) => C;
+export declare const useSmoothStatus: {
   (): {
     readonly type: "running";
   } | {
@@ -110,5 +110,4 @@ declare const useSmoothStatus: {
   }> | null;
 };
 //#endregion
-export { SmoothContextProvider, useSmoothStatus, useSmoothStatusStore, withSmoothContextProvider };
 //# sourceMappingURL=SmoothContext.d.ts.map

package/dist/utils/smooth/SmoothContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SmoothContext.d.ts","names":[],"sources":["../../../src/utils/smooth/SmoothContext.tsx"],"mappings":";;;cAmCa,uBAAuB,GAAG;cAgB1B,4BAA6B,UAAU,oBAClD,WAAW,MACV;cA2BY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAiB"}
+{"version":3,"file":"SmoothContext.d.ts","names":[],"sources":["../../../src/utils/smooth/SmoothContext.tsx"],"mappings":";;;qBAmCa,uBAAuB,GAAG;qBAgB1B,4BAA6B,UAAU,oBAClD,WAAW,MACV;qBA2BY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAiB"}

package/dist/utils/smooth/useSmooth.d.ts

@@ -3,7 +3,7 @@ import { MessagePartState, ReasoningMessagePart, TextMessagePart } from "@assist
 /**
  * Tuning options for the smooth text streaming animation.
  */
-type SmoothOptions = {
+export type SmoothOptions = {
   /**
    * Target time in milliseconds to drain the backlog of unrevealed
    * characters. Larger values reveal long backlogs more gradually.
@@ -53,7 +53,6 @@ type SmoothOptions = {
  * });
  * ```
  */
-declare const useSmooth: (state: MessagePartState & (TextMessagePart | ReasoningMessagePart), smooth?: boolean | SmoothOptions) => MessagePartState & (TextMessagePart | ReasoningMessagePart);
+export declare const useSmooth: (state: MessagePartState & (TextMessagePart | ReasoningMessagePart), smooth?: boolean | SmoothOptions) => MessagePartState & (TextMessagePart | ReasoningMessagePart);
 //#endregion
-export { SmoothOptions, useSmooth };
 //# sourceMappingURL=useSmooth.d.ts.map

package/dist/utils/smooth/useSmooth.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useSmooth.d.ts","names":[],"sources":["../../../src/utils/smooth/useSmooth.ts"],"mappings":";;;;;KAkBY;;;;;;EAMV;;;;;;EAMA;;;;;EAKA;;;;;;;;EAQA;;;;;;;;;;;;;;;;;;;;;;;;;cAgHW,YACX,OAAO,oBAAoB,kBAAkB,uBAC7C,mBAAkB,kBACjB,oBAAoB,kBAAkB"}
+{"version":3,"file":"useSmooth.d.ts","names":[],"sources":["../../../src/utils/smooth/useSmooth.ts"],"mappings":";;;;;YAkBY;;;;;;EAMV;;;;;;EAMA;;;;;EAKA;;;;;;;;EAQA;;;;;;;;;;;;;;;;;;;;;;;;;qBAgHW,YACX,OAAO,oBAAoB,kBAAkB,uBAC7C,mBAAkB,kBACjB,oBAAoB,kBAAkB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@assistant-ui/react",
-  "version": "0.15.20",
+  "version": "0.15.21",
   "description": "Open-source TypeScript/React library for building production-grade AI chat experiences",
   "keywords": [
     "ai",
@@ -55,15 +55,15 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "@assistant-ui/core": "^0.3.19",
-    "@assistant-ui/store": "^0.3.13",
-    "@assistant-ui/tap": "^0.9.17",
-    "assistant-cloud": "^0.2.1",
-    "assistant-stream": "^0.3.43",
+    "@assistant-ui/core": "^0.3.20",
+    "@assistant-ui/store": "^0.3.14",
+    "@assistant-ui/tap": "^0.9.18",
+    "assistant-cloud": "^0.2.2",
+    "assistant-stream": "^0.3.44",
     "radix-ui": "^1.6.7",
     "react-textarea-autosize": "^8.5.9",
-    "safe-content-frame": "^0.0.30",
-    "zod": "^4.5.4",
+    "safe-content-frame": "^0.0.31",
+    "zod": "^4.6.5",
     "zustand": "^5.0.15"
   },
   "peerDependencies": {
@@ -81,17 +81,17 @@
     }
   },
   "devDependencies": {
-    "@assistant-ui/vite": "0.0.17",
-    "@assistant-ui/x-buildutils": "0.0.27",
+    "@assistant-ui/vite": "0.0.18",
+    "@assistant-ui/x-buildutils": "0.0.28",
     "@testing-library/react": "^16.3.3",
     "@types/json-schema": "^7.0.15",
-    "@types/node": "^26.4.1",
-    "@types/react": "^19.2.18",
-    "@types/react-dom": "^19.2.7",
+    "@types/node": "^26.5.1",
+    "@types/react": "^19.3.0",
+    "@types/react-dom": "^19.3.0",
     "jsdom": "^30.0.1",
-    "react": "^19.2.8",
-    "react-dom": "^19.2.8",
-    "vitest": "^5.0.0"
+    "react": "^19.3.0",
+    "react-dom": "^19.3.0",
+    "vitest": "^5.0.1"
   },
   "publishConfig": {
     "access": "public",
@@ -109,6 +109,7 @@
   "scripts": {
     "build": "aui-build",
     "test": "vitest run",
+    "typecheck": "tsc --noEmit",
     "test:watch": "vitest"
   }
 }

package/src/mcp-apps/McpAppRenderer.test.tsx

@@ -70,8 +70,7 @@ const createPart = (
 });
 
 const createPartWithoutApp = (): ToolCallMessagePartProps => {
-  const part = createPart();
-  delete part.mcp;
+  const { mcp: _mcp, ...part } = createPart();
   return part;
 };
 

package/src/primitives/composer/ComposerAddAttachment.test.tsx

@@ -78,14 +78,16 @@ describe("ComposerPrimitiveAddAttachment", () => {
 
     const button = container.querySelector("button");
     expect(button).not.toBeNull();
+    if (!button) throw new Error("Attachment button was not rendered");
 
     await act(async () => {
-      button!.click();
+      button.click();
     });
 
     const input =
       document.querySelector<HTMLInputElement>('input[type="file"]');
     expect(input).not.toBeNull();
+    if (!input) throw new Error("File input was not rendered");
 
     const files = [
       new File(["a"], "unsupported.bin"),
@@ -96,13 +98,13 @@ describe("ComposerPrimitiveAddAttachment", () => {
       value: files,
     });
 
-    const result = input!.onchange?.call(input, {
-      target: input,
-    } as unknown as Event);
+    const event = new Event("change");
+    Object.defineProperty(event, "target", { value: input });
+    const result = input.onchange?.call(input, event);
 
     await expect(Promise.resolve(result)).resolves.toBeUndefined();
     expect(addAttachment).toHaveBeenCalledTimes(2);
     expect(errorSpy).not.toHaveBeenCalled();
-    expect(input!.isConnected).toBe(false);
+    expect(input.isConnected).toBe(false);
   });
 });

package/src/primitives/composer/ComposerRoot.test.tsx

@@ -354,9 +354,11 @@ describe("ComposerPrimitiveRoot compact mode", () => {
   );
 
   it("updates compact mode when the compact context multiline latch changes", async () => {
-    let compactContext: ComposerCompactContextValue | null = null;
+    const compactContext: { current: ComposerCompactContextValue | null } = {
+      current: null,
+    };
     const Probe = () => {
-      compactContext = useComposerCompactContextOptional();
+      compactContext.current = useComposerCompactContextOptional();
       return null;
     };
 
@@ -364,7 +366,7 @@ describe("ComposerPrimitiveRoot compact mode", () => {
       compact: true,
       children: <Probe />,
     });
-    const context = compactContext;
+    const context = compactContext.current;
     expect(context).not.toBeNull();
     if (!context) throw new Error("Composer compact context was not provided");
     expect(form.hasAttribute("data-compact")).toBe(true);

package/src/primitives/selectionToolbar/SelectionToolbarRoot.test.tsx

@@ -72,3 +72,47 @@ describe("SelectionToolbarPrimitiveRoot onMouseDown composition", () => {
     expect(notPrevented).toBe(false);
   });
 });
+
+describe("SelectionToolbarPrimitiveRoot frame cleanup", () => {
+  // Defer the frame instead of running it inline, so the window between the
+  // selection event and the frame is observable.
+  const deferFrames = () => {
+    const frames: FrameRequestCallback[] = [];
+    let nextHandle = 1;
+    vi.spyOn(window, "requestAnimationFrame").mockImplementation((cb) => {
+      frames.push(cb);
+      return nextHandle++;
+    });
+    const cancelAnimationFrame = vi
+      .spyOn(window, "cancelAnimationFrame")
+      .mockImplementation(() => {});
+    return { frames, cancelAnimationFrame };
+  };
+
+  it("cancels a queued selection frame when the toolbar unmounts", () => {
+    const { frames, cancelAnimationFrame } = deferFrames();
+    const { unmount } = render(<SelectionToolbarPrimitiveRoot />);
+
+    fireEvent.mouseUp(document);
+    expect(frames).toHaveLength(1);
+
+    unmount();
+
+    expect(cancelAnimationFrame).toHaveBeenCalledWith(1);
+  });
+
+  it("cancels the previous frame when another selection event arrives", () => {
+    const { frames, cancelAnimationFrame } = deferFrames();
+    const { unmount } = render(<SelectionToolbarPrimitiveRoot />);
+
+    fireEvent.mouseUp(document);
+    fireEvent.keyUp(document);
+    expect(frames).toHaveLength(2);
+    expect(cancelAnimationFrame).toHaveBeenCalledWith(1);
+
+    unmount();
+
+    expect(cancelAnimationFrame).toHaveBeenCalledTimes(2);
+    expect(cancelAnimationFrame).toHaveBeenLastCalledWith(2);
+  });
+});

package/src/primitives/selectionToolbar/SelectionToolbarRoot.tsx

@@ -51,8 +51,13 @@ export const SelectionToolbarPrimitiveRoot = forwardRef<
   const [info, setInfo] = useState<SelectionInfo | null>(null);
 
   useEffect(() => {
+    // Read the selection on the next frame so the browser has settled it.
+    let pendingFrame: number | null = null;
+
     const checkSelection = () => {
-      requestAnimationFrame(() => {
+      if (pendingFrame !== null) cancelAnimationFrame(pendingFrame);
+      pendingFrame = requestAnimationFrame(() => {
+        pendingFrame = null;
         const sel = window.getSelection();
         if (!sel || sel.isCollapsed) {
           setInfo(null);
@@ -94,6 +99,7 @@ export const SelectionToolbarPrimitiveRoot = forwardRef<
     document.addEventListener("scroll", handleScroll, true);
 
     return () => {
+      if (pendingFrame !== null) cancelAnimationFrame(pendingFrame);
       document.removeEventListener("mouseup", checkSelection);
       document.removeEventListener("keyup", checkSelection);
       document.removeEventListener("selectionchange", handleSelectionCollapse);