@assistant-ui/react 0.15.23 → 0.15.25

package/src/model-context/makeAssistantVisible.tsx

@@ -15,6 +15,27 @@ import { useAui } from "@assistant-ui/store";
 import { useComposedRefs } from "radix-ui/internal";
 import { tool } from "@assistant-ui/core";
 
+const DEFAULT_ACTION_SETTLE_DELAY_MS = 2000;
+const MAX_ACTION_SETTLE_DELAY_MS = 2_147_483_647;
+
+const waitForSettle = async (settleDelayMs: number) => {
+  const delay =
+    Number.isFinite(settleDelayMs) &&
+    settleDelayMs >= 0 &&
+    settleDelayMs <= MAX_ACTION_SETTLE_DELAY_MS
+      ? settleDelayMs
+      : DEFAULT_ACTION_SETTLE_DELAY_MS;
+  if (delay === 0) return;
+  await new Promise<void>((resolve) => setTimeout(resolve, delay));
+};
+
+const readActionSettleDelay = (element: HTMLElement) => {
+  const value = element.dataset.actionSettleDelay;
+  return value === undefined || value.trim() === ""
+    ? DEFAULT_ACTION_SETTLE_DELAY_MS
+    : Number(value);
+};
+
 const click = tool({
   parameters: {
     type: "object",
@@ -30,9 +51,7 @@ const click = tool({
     const el = document.querySelector(`[data-click-id='${escapedClickId}']`);
     if (el instanceof HTMLElement) {
       el.click();
-
-      // todo make adjustable
-      await new Promise((resolve) => setTimeout(resolve, 2000));
+      await waitForSettle(readActionSettleDelay(el));
       return {};
     } else {
       return "Element not found";
@@ -77,9 +96,7 @@ const edit = tool({
       setNativeValue(el, value);
       el.dispatchEvent(new Event("input", { bubbles: true }));
       el.dispatchEvent(new Event("change", { bubbles: true }));
-
-      // todo make adjustable
-      await new Promise((resolve) => setTimeout(resolve, 2000));
+      await waitForSettle(readActionSettleDelay(el));
       return {};
     } else {
       return "Element not found";
@@ -91,8 +108,23 @@ const ReadableContext = createContext<boolean>(false);
 
 export const makeAssistantVisible = <T extends ComponentType<any>>(
   Component: T,
-  config?: { clickable?: boolean | undefined; editable?: boolean | undefined },
+  config?: {
+    clickable?: boolean | undefined;
+    editable?: boolean | undefined;
+    settleDelayMs?: number | undefined;
+  },
 ) => {
+  const settleDelayMs = config?.settleDelayMs ?? DEFAULT_ACTION_SETTLE_DELAY_MS;
+  if (
+    !Number.isFinite(settleDelayMs) ||
+    settleDelayMs < 0 ||
+    settleDelayMs > MAX_ACTION_SETTLE_DELAY_MS
+  ) {
+    throw new RangeError(
+      `settleDelayMs must be between 0 and ${MAX_ACTION_SETTLE_DELAY_MS}`,
+    );
+  }
+
   const ReadableComponent = forwardRef(
     (props: PropsWithoutRef<T>, outerRef: ForwardedRef<any>) => {
       const isNestedReadable = useContext(ReadableContext);
@@ -127,6 +159,10 @@ export const makeAssistantVisible = <T extends ComponentType<any>>(
             {...(props as any)}
             {...(config?.clickable ? { "data-click-id": clickId } : {})}
             {...(config?.editable ? { "data-edit-id": clickId } : {})}
+            {...(config?.settleDelayMs !== undefined &&
+            (config.clickable || config.editable)
+              ? { "data-action-settle-delay": settleDelayMs }
+              : {})}
             ref={ref}
           />
         </ReadableContext.Provider>

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

@@ -133,6 +133,7 @@ const fireKeyDown = (
     ctrlKey?: boolean;
     metaKey?: boolean;
     isComposing?: boolean;
+    keyCode?: number;
   } = {},
 ): KeyboardEvent => {
   const event = new KeyboardEvent("keydown", {
@@ -143,6 +144,7 @@ const fireKeyDown = (
     ctrlKey: opts.ctrlKey ?? false,
     metaKey: opts.metaKey ?? false,
     isComposing: opts.isComposing ?? false,
+    keyCode: opts.keyCode ?? 0,
   });
   textarea.dispatchEvent(event);
   return event;
@@ -441,6 +443,20 @@ describe("ComposerPrimitiveInput", () => {
       expect(event.defaultPrevented).toBe(false);
     });
 
+    it("ignores the Enter that commits an IME composition after compositionend (Safari)", async () => {
+      const textarea = await mount();
+
+      let event!: KeyboardEvent;
+      await act(async () => {
+        fireCompositionStart(textarea);
+        fireCompositionEnd(textarea, "日本語");
+        event = fireKeyDown(textarea, { key: "Enter", keyCode: 229 });
+      });
+
+      expect(requestSubmitSpy).not.toHaveBeenCalled();
+      expect(event.defaultPrevented).toBe(false);
+    });
+
     it("submitMode='ctrlEnter' submits on Cmd/Ctrl+Enter but not on plain Enter", async () => {
       const textarea = await mount({ submitMode: "ctrlEnter" });
 
@@ -566,13 +582,14 @@ describe("ComposerPrimitiveInput", () => {
   describe("escape behavior", () => {
     const fireEscape = (
       textarea: HTMLTextAreaElement,
-      opts: { isComposing?: boolean } = {},
+      opts: { isComposing?: boolean; keyCode?: number } = {},
     ): KeyboardEvent => {
       const event = new KeyboardEvent("keydown", {
         bubbles: true,
         cancelable: true,
         key: "Escape",
         isComposing: opts.isComposing ?? false,
+        keyCode: opts.keyCode ?? 0,
       });
       textarea.dispatchEvent(event);
       escapeKeydownHandler?.(event);
@@ -604,6 +621,21 @@ describe("ComposerPrimitiveInput", () => {
       expect(cancelSpy).not.toHaveBeenCalled();
       expect(event.defaultPrevented).toBe(false);
     });
+
+    it("ignores the Escape that cancels an IME composition after compositionend (Safari)", async () => {
+      composerState.canCancel = true;
+      const textarea = await mount();
+
+      let event!: KeyboardEvent;
+      await act(async () => {
+        fireCompositionStart(textarea);
+        fireCompositionEnd(textarea, "");
+        event = fireEscape(textarea, { keyCode: 229 });
+      });
+
+      expect(cancelSpy).not.toHaveBeenCalled();
+      expect(event.defaultPrevented).toBe(false);
+    });
   });
 
   describe("paste attachments", () => {

package/src/primitives/composer/ComposerInput.tsx

@@ -22,6 +22,7 @@ import { useEscapeKeydown } from "radix-ui/internal";
 import { useOnScrollToBottom } from "../../utils/hooks/useOnScrollToBottom";
 import { useMediaQuery } from "../../utils/hooks/useMediaQuery";
 import { renderSlot } from "../../utils/Primitive";
+import { isCompositionKey } from "../../utils/isCompositionKey";
 import { useAui } from "@assistant-ui/store";
 import { flushTapSync } from "@assistant-ui/tap";
 import { useComposerInputPluginRegistryOptional } from "./ComposerInputPluginContext";
@@ -118,7 +119,7 @@ export namespace ComposerPrimitiveInput {
  * keyboard shortcuts, file paste support, and intelligent focus management.
  * It integrates with the composer context to manage message state and submission.
  *
- * When rendered inside `Unstable_TriggerPopoverRoot` and a popover is open, the
+ * When rendered inside `TriggerPopoverRoot` and a popover is open, the
  * underlying `<textarea>` automatically receives `aria-controls`,
  * `aria-expanded`, `aria-haspopup`, and `aria-activedescendant` for the
  * combobox relationship. These computed attributes override user-provided
@@ -200,7 +201,7 @@ export const ComposerPrimitiveInput = forwardRef<
       if (!textareaRef.current?.contains(e.target as Node)) return;
 
       // ignore IME composition events
-      if (e.isComposing) return;
+      if (isCompositionKey(e)) return;
 
       // Let registered plugins (mention, slash command, etc.) handle Escape first
       if (pluginRegistry) {
@@ -222,7 +223,7 @@ export const ComposerPrimitiveInput = forwardRef<
       if (isDisabled) return;
 
       // ignore IME composition events
-      if (e.nativeEvent.isComposing) return;
+      if (isCompositionKey(e.nativeEvent)) return;
 
       // Let registered plugins (mention, slash command, etc.) handle keyboard events first
       if (pluginRegistry) {

package/src/primitives/composer/trigger/TriggerPopover.tsx

@@ -2,7 +2,7 @@
 
 import { useAui, useAuiState } from "@assistant-ui/store";
 import { useResource } from "@assistant-ui/tap";
-import type { Unstable_TriggerAdapter } from "@assistant-ui/core";
+import type { TriggerAdapter } from "@assistant-ui/core";
 import {
   createContext,
   forwardRef,
@@ -74,7 +74,7 @@ export namespace ComposerPrimitiveTriggerPopover {
     /** Overrides trigger detection for both textarea and Lexical inputs. `endOffset` is the exclusive replace bound. */
     readonly matcher?: TriggerMatcher | undefined;
     /** Adapter providing categories and items. */
-    readonly adapter?: Unstable_TriggerAdapter | undefined;
+    readonly adapter?: TriggerAdapter | undefined;
     /** Whether the adapter is resolving items, surfaced to the popover scope for async sources. @default false */
     readonly isLoading?: boolean | undefined;
   };
@@ -89,22 +89,22 @@ export namespace ComposerPrimitiveTriggerPopover {
  * `<TriggerPopover.Directive>` or `<TriggerPopover.Action>` as a child. Without
  * a behavior the trigger stays closed.
  *
- * Must be placed inside `ComposerPrimitive.Unstable_TriggerPopoverRoot`.
+ * Must be placed inside `ComposerPrimitive.TriggerPopoverRoot`.
  *
  * @example
  * ```tsx
- * <ComposerPrimitive.Unstable_TriggerPopover
+ * <ComposerPrimitive.TriggerPopover
  *   char="@"
  *   adapter={mentionAdapter}
  * >
- *   <ComposerPrimitive.Unstable_TriggerPopover.Directive formatter={formatter} />
- *   <ComposerPrimitive.Unstable_TriggerPopoverCategories>
+ *   <ComposerPrimitive.TriggerPopover.Directive formatter={formatter} />
+ *   <ComposerPrimitive.TriggerPopoverCategories>
  *     {(cats) => cats.map(...)}
- *   </ComposerPrimitive.Unstable_TriggerPopoverCategories>
- *   <ComposerPrimitive.Unstable_TriggerPopoverItems>
+ *   </ComposerPrimitive.TriggerPopoverCategories>
+ *   <ComposerPrimitive.TriggerPopoverItems>
  *     {(items) => items.map(...)}
- *   </ComposerPrimitive.Unstable_TriggerPopoverItems>
- * </ComposerPrimitive.Unstable_TriggerPopover>
+ *   </ComposerPrimitive.TriggerPopoverItems>
+ * </ComposerPrimitive.TriggerPopover>
  * ```
  */
 export const ComposerPrimitiveTriggerPopover = forwardRef<
@@ -196,7 +196,7 @@ export const ComposerPrimitiveTriggerPopover = forwardRef<
         ...(behavior ? { behavior } : {}),
         resource: getResource(),
       });
-    }, [root, char, hasMatcher, behavior]);
+    }, [root, char, hasMatcher, registeredMatcher, behavior]);
 
     const pluginRegistry = useComposerInputPluginRegistryOptional();
     useEffect(() => {

package/src/primitives/composer/trigger/TriggerPopoverAction.tsx

@@ -1,20 +1,17 @@
 "use client";
 
-import type {
-  Unstable_DirectiveFormatter,
-  Unstable_TriggerItem,
-} from "@assistant-ui/core";
-import { unstable_defaultDirectiveFormatter } from "@assistant-ui/core";
+import type { DirectiveFormatter, TriggerItem } from "@assistant-ui/core";
+import { defaultDirectiveFormatter } from "@assistant-ui/core";
 import { useEffect, useInsertionEffect, useRef, type FC } from "react";
 import { useTriggerBehaviorRegistration } from "./TriggerPopover";
 import type { TriggerBehavior } from "./triggerSelectionResource";
 
 export namespace ComposerPrimitiveTriggerPopoverAction {
   export type Props = {
-    /** Defaults to `unstable_defaultDirectiveFormatter`. */
-    readonly formatter?: Unstable_DirectiveFormatter | undefined;
+    /** Defaults to `defaultDirectiveFormatter`. */
+    readonly formatter?: DirectiveFormatter | undefined;
     /** Fires the moment an item is selected; runs regardless of `removeOnExecute`. */
-    readonly onExecute: (item: Unstable_TriggerItem) => void;
+    readonly onExecute: (item: TriggerItem) => void;
     /** When true, strips the trigger text after executing. Defaults to `false` (keeps audit-trail chip). */
     readonly removeOnExecute?: boolean | undefined;
   };
@@ -25,16 +22,16 @@ export namespace ComposerPrimitiveTriggerPopoverAction {
  * optionally leaving a directive chip behind as an audit trail. Render exactly
  * one behavior sub-primitive per `<TriggerPopover>`.
  *
- * Exposed as `ComposerPrimitive.Unstable_TriggerPopover.Action`.
+ * Exposed as `ComposerPrimitive.TriggerPopover.Action`.
  *
  * @example
  * ```tsx
- * <ComposerPrimitive.Unstable_TriggerPopover char="/" adapter={slashAdapter}>
- *   <ComposerPrimitive.Unstable_TriggerPopover.Action
+ * <ComposerPrimitive.TriggerPopover char="/" adapter={slashAdapter}>
+ *   <ComposerPrimitive.TriggerPopover.Action
  *     onExecute={(item) => commandHandlers[item.id]?.()}
  *     removeOnExecute={false}
  *   />
- * </ComposerPrimitive.Unstable_TriggerPopover>
+ * </ComposerPrimitive.TriggerPopover>
  * ```
  */
 export const ComposerPrimitiveTriggerPopoverAction: FC<
@@ -49,7 +46,7 @@ export const ComposerPrimitiveTriggerPopoverAction: FC<
   useEffect(() => {
     const behavior: TriggerBehavior = {
       kind: "action",
-      formatter: formatter ?? unstable_defaultDirectiveFormatter,
+      formatter: formatter ?? defaultDirectiveFormatter,
       onExecute: (item) => onExecuteRef.current(item),
       ...(removeOnExecute !== undefined ? { removeOnExecute } : {}),
     };

package/src/primitives/composer/trigger/TriggerPopoverCategories.tsx

@@ -10,7 +10,7 @@ import {
 } from "react";
 import { composeEventHandlers } from "radix-ui/internal";
 import { useTriggerPopoverScopeContext } from "./TriggerPopover";
-import type { Unstable_TriggerCategory } from "@assistant-ui/core";
+import type { TriggerCategory } from "@assistant-ui/core";
 
 export namespace ComposerPrimitiveTriggerPopoverCategories {
   export type Element = ComponentRef<typeof Primitive.div>;
@@ -18,7 +18,7 @@ export namespace ComposerPrimitiveTriggerPopoverCategories {
     ComponentPropsWithoutRef<typeof Primitive.div>,
     "children"
   > & {
-    children: (categories: readonly Unstable_TriggerCategory[]) => ReactNode;
+    children: (categories: readonly TriggerCategory[]) => ReactNode;
   };
 }
 

package/src/primitives/composer/trigger/TriggerPopoverDirective.tsx

@@ -1,20 +1,17 @@
 "use client";
 
-import type {
-  Unstable_DirectiveFormatter,
-  Unstable_TriggerItem,
-} from "@assistant-ui/core";
-import { unstable_defaultDirectiveFormatter } from "@assistant-ui/core";
+import type { DirectiveFormatter, TriggerItem } from "@assistant-ui/core";
+import { defaultDirectiveFormatter } from "@assistant-ui/core";
 import { useEffect, useInsertionEffect, useRef, type FC } from "react";
 import { useTriggerBehaviorRegistration } from "./TriggerPopover";
 import type { TriggerBehavior } from "./triggerSelectionResource";
 
 export namespace ComposerPrimitiveTriggerPopoverDirective {
   export type Props = {
-    /** Defaults to `unstable_defaultDirectiveFormatter`. */
-    readonly formatter?: Unstable_DirectiveFormatter | undefined;
+    /** Defaults to `defaultDirectiveFormatter`. */
+    readonly formatter?: DirectiveFormatter | undefined;
     /** Fires after an item has been inserted into the composer. */
-    readonly onInserted?: ((item: Unstable_TriggerItem) => void) | undefined;
+    readonly onInserted?: ((item: TriggerItem) => void) | undefined;
   };
 }
 
@@ -22,16 +19,16 @@ export namespace ComposerPrimitiveTriggerPopoverDirective {
  * Configures a `<TriggerPopover>` to insert a directive chip when an item is
  * selected. Render exactly one behavior sub-primitive per `<TriggerPopover>`.
  *
- * Exposed as `ComposerPrimitive.Unstable_TriggerPopover.Directive`.
+ * Exposed as `ComposerPrimitive.TriggerPopover.Directive`.
  *
  * @example
  * ```tsx
- * <ComposerPrimitive.Unstable_TriggerPopover char="@" adapter={mentionAdapter}>
- *   <ComposerPrimitive.Unstable_TriggerPopover.Directive
- *     formatter={unstable_defaultDirectiveFormatter}
+ * <ComposerPrimitive.TriggerPopover char="@" adapter={mentionAdapter}>
+ *   <ComposerPrimitive.TriggerPopover.Directive
+ *     formatter={defaultDirectiveFormatter}
  *     onInserted={(item) => track("mention", item.id)}
  *   />
- * </ComposerPrimitive.Unstable_TriggerPopover>
+ * </ComposerPrimitive.TriggerPopover>
  * ```
  */
 export const ComposerPrimitiveTriggerPopoverDirective: FC<
@@ -46,7 +43,7 @@ export const ComposerPrimitiveTriggerPopoverDirective: FC<
   useEffect(() => {
     const behavior: TriggerBehavior = {
       kind: "directive",
-      formatter: formatter ?? unstable_defaultDirectiveFormatter,
+      formatter: formatter ?? defaultDirectiveFormatter,
       onInserted: (item) => onInsertedRef.current?.(item),
     };
     return register(behavior);

package/src/primitives/composer/trigger/TriggerPopoverExports.test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, expectTypeOf, it } from "vitest";
+import * as ComposerPrimitive from "../../composer";
+import {
+  defaultDirectiveFormatter,
+  unstable_defaultDirectiveFormatter,
+  type DirectiveFormatter,
+  type TriggerAdapter,
+  type TriggerCategory,
+  type TriggerItem,
+  type Unstable_DirectiveFormatter,
+  type Unstable_TriggerBehavior,
+  type Unstable_TriggerItem,
+} from "../../../index";
+import type { TriggerBehavior } from "./triggerSelectionResource";
+
+describe("stable trigger popover exports", () => {
+  it("keeps every old composer member as an alias of its stable member", () => {
+    expect(ComposerPrimitive.Unstable_TriggerPopover).toBe(
+      ComposerPrimitive.TriggerPopover,
+    );
+    expect(ComposerPrimitive.Unstable_TriggerPopover.Directive).toBe(
+      ComposerPrimitive.TriggerPopover.Directive,
+    );
+    expect(ComposerPrimitive.Unstable_TriggerPopover.Action).toBe(
+      ComposerPrimitive.TriggerPopover.Action,
+    );
+    expect(ComposerPrimitive.Unstable_TriggerPopoverRoot).toBe(
+      ComposerPrimitive.TriggerPopoverRoot,
+    );
+    expect(ComposerPrimitive.Unstable_TriggerPopoverCategories).toBe(
+      ComposerPrimitive.TriggerPopoverCategories,
+    );
+    expect(ComposerPrimitive.Unstable_TriggerPopoverCategoryItem).toBe(
+      ComposerPrimitive.TriggerPopoverCategoryItem,
+    );
+    expect(ComposerPrimitive.Unstable_TriggerPopoverItems).toBe(
+      ComposerPrimitive.TriggerPopoverItems,
+    );
+    expect(ComposerPrimitive.Unstable_TriggerPopoverItem).toBe(
+      ComposerPrimitive.TriggerPopoverItem,
+    );
+    expect(ComposerPrimitive.Unstable_TriggerPopoverBack).toBe(
+      ComposerPrimitive.TriggerPopoverBack,
+    );
+  });
+
+  it("keeps the old members' namespaced prop types", () => {
+    expectTypeOf<ComposerPrimitive.Unstable_TriggerPopoverItem.Props>().toEqualTypeOf<ComposerPrimitive.TriggerPopoverItem.Props>();
+    expectTypeOf<ComposerPrimitive.Unstable_TriggerPopoverBack.Element>().toEqualTypeOf<ComposerPrimitive.TriggerPopoverBack.Element>();
+  });
+
+  it("exports the stable adapter, item, category and formatter names beside the old ones", () => {
+    expect(unstable_defaultDirectiveFormatter).toBe(defaultDirectiveFormatter);
+    expectTypeOf<Unstable_TriggerItem>().toEqualTypeOf<TriggerItem>();
+    expectTypeOf<Unstable_DirectiveFormatter>().toEqualTypeOf<DirectiveFormatter>();
+    expectTypeOf<TriggerAdapter["categories"]>().returns.toEqualTypeOf<
+      readonly TriggerCategory[]
+    >();
+    expectTypeOf<Unstable_TriggerBehavior>().toEqualTypeOf<TriggerBehavior>();
+  });
+});

package/src/primitives/composer/trigger/TriggerPopoverItems.tsx

@@ -10,7 +10,7 @@ import {
 } from "react";
 import { composeEventHandlers } from "radix-ui/internal";
 import { useTriggerPopoverScopeContext } from "./TriggerPopover";
-import type { Unstable_TriggerItem } from "@assistant-ui/core";
+import type { TriggerItem } from "@assistant-ui/core";
 
 export namespace ComposerPrimitiveTriggerPopoverItems {
   export type Element = ComponentRef<typeof Primitive.div>;
@@ -18,7 +18,7 @@ export namespace ComposerPrimitiveTriggerPopoverItems {
     ComponentPropsWithoutRef<typeof Primitive.div>,
     "children"
   > & {
-    children: (items: readonly Unstable_TriggerItem[]) => ReactNode;
+    children: (items: readonly TriggerItem[]) => ReactNode;
   };
 }
 
@@ -53,7 +53,7 @@ ComposerPrimitiveTriggerPopoverItems.displayName =
 export namespace ComposerPrimitiveTriggerPopoverItem {
   export type Element = ComponentRef<typeof Primitive.button>;
   export type Props = ComponentPropsWithoutRef<typeof Primitive.button> & {
-    item: Unstable_TriggerItem;
+    item: TriggerItem;
     index?: number | undefined;
   };
 }

package/src/primitives/composer/trigger/TriggerPopoverRootContext.tsx

@@ -294,21 +294,21 @@ const TriggerPopoverRootInner: FC<
  *
  * @example
  * ```tsx
- * <ComposerPrimitive.Unstable_TriggerPopoverRoot>
- *   <ComposerPrimitive.Unstable_TriggerPopover char="@" adapter={mentionAdapter}>
- *     <ComposerPrimitive.Unstable_TriggerPopover.Directive formatter={formatter} />
+ * <ComposerPrimitive.TriggerPopoverRoot>
+ *   <ComposerPrimitive.TriggerPopover char="@" adapter={mentionAdapter}>
+ *     <ComposerPrimitive.TriggerPopover.Directive formatter={formatter} />
  *     ...
- *   </ComposerPrimitive.Unstable_TriggerPopover>
+ *   </ComposerPrimitive.TriggerPopover>
  *
- *   <ComposerPrimitive.Unstable_TriggerPopover char="/" adapter={slashAdapter}>
- *     <ComposerPrimitive.Unstable_TriggerPopover.Action onExecute={handler} />
+ *   <ComposerPrimitive.TriggerPopover char="/" adapter={slashAdapter}>
+ *     <ComposerPrimitive.TriggerPopover.Action onExecute={handler} />
  *     ...
- *   </ComposerPrimitive.Unstable_TriggerPopover>
+ *   </ComposerPrimitive.TriggerPopover>
  *
  *   <ComposerPrimitive.Root>
  *     <ComposerPrimitive.Input />
  *   </ComposerPrimitive.Root>
- * </ComposerPrimitive.Unstable_TriggerPopoverRoot>
+ * </ComposerPrimitive.TriggerPopoverRoot>
  * ```
  */
 export const ComposerPrimitiveTriggerPopoverRoot: FC<

package/src/primitives/composer.ts

@@ -1,3 +1,5 @@
+import type { TriggerMatch, TriggerMatcher } from "./composer/trigger";
+
 export { ComposerPrimitiveRoot as Root } from "./composer/ComposerRoot";
 export { ComposerPrimitiveInput as Input } from "./composer/ComposerInput";
 export { ComposerPrimitiveSend as Send } from "./composer/ComposerSend";
@@ -15,12 +17,26 @@ export { ComposerPrimitiveQuoteText as QuoteText } from "./composer/ComposerQuot
 export { ComposerPrimitiveQuoteDismiss as QuoteDismiss } from "./composer/ComposerQuote";
 export { ComposerPrimitiveQueue as Queue } from "./composer/ComposerQueue";
 
+export { ComposerPrimitiveTriggerPopover as TriggerPopover } from "./composer/trigger";
+/** @deprecated Use `ComposerPrimitive.TriggerPopover` instead. */
 export { ComposerPrimitiveTriggerPopover as Unstable_TriggerPopover } from "./composer/trigger";
+export { ComposerPrimitiveTriggerPopoverRoot as TriggerPopoverRoot } from "./composer/trigger";
+/** @deprecated Use `ComposerPrimitive.TriggerPopoverRoot` instead. */
 export { ComposerPrimitiveTriggerPopoverRoot as Unstable_TriggerPopoverRoot } from "./composer/trigger";
+export { ComposerPrimitiveTriggerPopoverCategories as TriggerPopoverCategories } from "./composer/trigger";
+/** @deprecated Use `ComposerPrimitive.TriggerPopoverCategories` instead. */
 export { ComposerPrimitiveTriggerPopoverCategories as Unstable_TriggerPopoverCategories } from "./composer/trigger";
+export { ComposerPrimitiveTriggerPopoverCategoryItem as TriggerPopoverCategoryItem } from "./composer/trigger";
+/** @deprecated Use `ComposerPrimitive.TriggerPopoverCategoryItem` instead. */
 export { ComposerPrimitiveTriggerPopoverCategoryItem as Unstable_TriggerPopoverCategoryItem } from "./composer/trigger";
+export { ComposerPrimitiveTriggerPopoverItems as TriggerPopoverItems } from "./composer/trigger";
+/** @deprecated Use `ComposerPrimitive.TriggerPopoverItems` instead. */
 export { ComposerPrimitiveTriggerPopoverItems as Unstable_TriggerPopoverItems } from "./composer/trigger";
+export { ComposerPrimitiveTriggerPopoverItem as TriggerPopoverItem } from "./composer/trigger";
+/** @deprecated Use `ComposerPrimitive.TriggerPopoverItem` instead. */
 export { ComposerPrimitiveTriggerPopoverItem as Unstable_TriggerPopoverItem } from "./composer/trigger";
+export { ComposerPrimitiveTriggerPopoverBack as TriggerPopoverBack } from "./composer/trigger";
+/** @deprecated Use `ComposerPrimitive.TriggerPopoverBack` instead. */
 export { ComposerPrimitiveTriggerPopoverBack as Unstable_TriggerPopoverBack } from "./composer/trigger";
 export { useTriggerPopoverRootContext as unstable_useTriggerPopoverRootContext } from "./composer/trigger";
 export { useTriggerPopoverRootContextOptional as unstable_useTriggerPopoverRootContextOptional } from "./composer/trigger";
@@ -29,4 +45,8 @@ export { useTriggerPopoverScopeContextOptional as unstable_useTriggerPopoverScop
 export { useTriggerPopoverTriggers as unstable_useTriggerPopoverTriggers } from "./composer/trigger";
 export { useTriggerPopoverTriggersOptional as unstable_useTriggerPopoverTriggersOptional } from "./composer/trigger";
 export type { RegisteredTrigger as Unstable_RegisteredTrigger } from "./composer/trigger";
-export type { TriggerMatcher as Unstable_TriggerMatcher } from "./composer/trigger";
+export type { TriggerMatch, TriggerMatcher } from "./composer/trigger";
+/** @deprecated Use `TriggerMatcher` instead. */
+export type Unstable_TriggerMatcher = TriggerMatcher;
+/** @deprecated Use `TriggerMatch` instead. */
+export type Unstable_TriggerMatch = TriggerMatch;