@assistant-ui/core 0.2.4 → 0.2.6

package/dist/react/primitives/message/MessageGroupedParts.d.ts

@@ -1,68 +1,75 @@
-import { type ReactNode } from "react";
-import type { PartState } from "../../../store/scopes/part.js";
-import type { MessagePartStatus, ToolCallMessagePartStatus } from "../../../types/message.js";
-import { type GroupKey } from "../../utils/groupParts.js";
-import { type EnrichedPartState } from "./MessageParts.js";
-export declare namespace MessagePrimitiveGroupedParts {
+import { MessagePartStatus, ToolCallMessagePartStatus } from "../../../types/message.js";
+import { PartState } from "../../../store/scopes/part.js";
+import { EnrichedPartState } from "./MessageParts.js";
+import { ReactNode } from "react";
+
+//#region src/react/primitives/message/MessageGroupedParts.d.ts
+declare namespace MessagePrimitiveGroupedParts {
+  /**
+   * A coalesced group of adjacent parts. Surfaced through the same
+   * `{ part }` channel as a leaf {@link EnrichedPartState} so consumers
+   * dispatch on a single `switch (part.type)`. `type` is the group key
+   * (always `"group-…"`); `status` mirrors the last contained part.
+   */
+  type GroupPart<TKey extends `group-${string}` = `group-${string}`> = {
+    readonly type: TKey;
+    readonly status: MessagePartStatus | ToolCallMessagePartStatus;
+    readonly indices: readonly number[];
+  };
+  type RenderInfo<TKey extends `group-${string}` = `group-${string}`> = {
     /**
-     * A coalesced group of adjacent parts. Surfaced through the same
-     * `{ part }` channel as a leaf {@link EnrichedPartState} so consumers
-     * dispatch on a single `switch (part.type)`. `type` is the group key
-     * (always `"group-…"`); `status` mirrors the last contained part.
+     * Either a coalesced group ({@link GroupPart}, identified by a
+     * `group-…` `type`) or a single enriched part. Use one switch over
+     * `part.type` to handle both.
      */
-    type GroupPart<TKey extends `group-${string}` = `group-${string}`> = {
-        readonly type: TKey;
-        readonly status: MessagePartStatus | ToolCallMessagePartStatus;
-        readonly indices: readonly number[];
-    };
-    type RenderInfo<TKey extends `group-${string}` = `group-${string}`> = {
-        /**
-         * Either a coalesced group ({@link GroupPart}, identified by a
-         * `group-…` `type`) or a single enriched part. Use one switch over
-         * `part.type` to handle both.
-         */
-        readonly part: GroupPart<TKey> | EnrichedPartState;
-        /**
-         * For group nodes: the recursively-rendered subtree (subgroups +
-         * leaf parts). For leaf parts: a sentinel that throws when rendered
-         * — accidental fall-through (`default: return children;`) errors
-         * loudly instead of silently rendering nothing.
-         */
-        readonly children: ReactNode;
-    };
-    type Props<TKey extends `group-${string}` = `group-${string}`> = {
-        /**
-         * Maps each part to its group key path. Adjacent parts that share a
-         * prefix coalesce up to that prefix. Return `null`, `undefined`, or
-         * `[]` to leave a part ungrouped — it will be rendered as a leaf
-         * through `children` with `part` set to its {@link EnrichedPartState}.
-         *
-         * Keys must start with `"group-"` so the renderer's
-         * `switch (part.type)` can distinguish groups from real part types.
-         *
-         * For best performance, pass a stable reference (module-level
-         * constant or `useCallback`).
-         *
-         * @example
-         * ```ts
-         * const groupBy = (part) =>
-         *   part.type === "reasoning" ? ["group-thought", "group-reasoning"] :
-         *   part.type === "tool-call" ? ["group-thought", "group-tool"] :
-         *   null;
-         * ```
-         */
-        readonly groupBy: (part: PartState, index: number, parts: readonly PartState[]) => GroupKey<TKey>;
-        /**
-         * Render function called once per group node and once per leaf part.
-         * Switch on `part.type`: `"group-…"` cases wrap `children`; real
-         * part types (`"text"`, `"tool-call"`, …) render the part directly.
-         *
-         * Leaf parts receive the same {@link EnrichedPartState} that
-         * `<MessagePrimitive.Parts>` would produce (`toolUI`, `addResult`,
-         * `resume`, `dataRendererUI`).
-         */
-        readonly children: (info: RenderInfo<TKey>) => ReactNode;
-    };
+    readonly part: GroupPart<TKey> | EnrichedPartState;
+    /**
+     * For group nodes: the recursively-rendered subtree (subgroups +
+     * leaf parts). For leaf parts: a sentinel that throws when rendered
+     * — accidental fall-through (`default: return children;`) errors
+     * loudly instead of silently rendering nothing.
+     */
+    readonly children: ReactNode;
+  };
+  type Props<TKey extends `group-${string}` = `group-${string}`> = {
+    /**
+     * Maps each part to a group-key path. Adjacent parts that share a
+     * prefix coalesce into the same group. Return `[]` (or `null`) to
+     * leave a part ungrouped.
+     *
+     * Group keys must start with `"group-"` so the renderer's
+     * `switch (part.type)` can tell groups apart from real part types.
+     *
+     * **Prefer {@link groupPartByType}** for the common case of mapping by
+     * `part.type` — it ships a stable memo fingerprint so the tree
+     * survives unrelated re-renders. Use an inline function only when
+     * the helper isn't expressive enough (e.g. branching on
+     * `part.toolName` or part metadata).
+     *
+     * @example
+     * ```tsx
+     * import { groupPartByType } from "@assistant-ui/react";
+     *
+     * <MessagePrimitive.GroupedParts
+     *   groupBy={groupPartByType({
+     *     reasoning: ["group-thought", "group-reasoning"],
+     *     "tool-call": ["group-thought", "group-tool"],
+     *   })}
+     * >
+     * ```
+     */
+    readonly groupBy: (part: PartState) => readonly TKey[] | null;
+    /**
+     * Render function called once per group node and once per leaf part.
+     * Switch on `part.type`: `"group-…"` cases wrap `children`; real
+     * part types (`"text"`, `"tool-call"`, …) render the part directly.
+     *
+     * Leaf parts receive the same {@link EnrichedPartState} that
+     * `<MessagePrimitive.Parts>` would produce (`toolUI`, `addResult`,
+     * `resume`, `respondToApproval`, `dataRendererUI`).
+     */
+    readonly children: (info: RenderInfo<TKey>) => ReactNode;
+  };
 }
 /**
  * Groups adjacent message parts into a tree of coalesced runs and
@@ -78,11 +85,10 @@ export declare namespace MessagePrimitiveGroupedParts {
  * @example
  * ```tsx
  * <MessagePrimitive.GroupedParts
- *   groupBy={(part) =>
- *     part.type === "reasoning" ? ["group-thought", "group-reasoning"] :
- *     part.type === "tool-call" ? ["group-thought", "group-tool"] :
- *     null
- *   }
+ *   groupBy={groupPartByType({
+ *     reasoning: ["group-thought", "group-reasoning"],
+ *     "tool-call": ["group-thought", "group-tool"],
+ *   })}
  * >
  *   {({ part, children }) => {
  *     switch (part.type) {
@@ -97,8 +103,13 @@ export declare namespace MessagePrimitiveGroupedParts {
  * </MessagePrimitive.GroupedParts>
  * ```
  */
-export declare const MessagePrimitiveGroupedParts: {
-    <TKey extends `group-${string}`>({ groupBy, children, }: MessagePrimitiveGroupedParts.Props<TKey>): ReactNode;
-    displayName: string;
+declare const MessagePrimitiveGroupedParts: {
+  <TKey extends `group-${string}`>({
+    groupBy,
+    children
+  }: MessagePrimitiveGroupedParts.Props<TKey>): ReactNode;
+  displayName: string;
 };
+//#endregion
+export { MessagePrimitiveGroupedParts };
 //# sourceMappingURL=MessageGroupedParts.d.ts.map

package/dist/react/primitives/message/MessageGroupedParts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MessageGroupedParts.d.ts","sourceRoot":"","sources":["../../../../src/react/primitives/message/MessageGroupedParts.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAqB,KAAK,SAAS,EAAW,MAAM,OAAO,CAAC;AAGnE,OAAO,KAAK,EAAE,SAAS,EAAE,sCAAmC;AAC5D,OAAO,KAAK,EACV,iBAAiB,EACjB,yBAAyB,EAC1B,kCAA+B;AAChC,OAAO,EAEL,KAAK,QAAQ,EAGd,kCAA+B;AAChC,OAAO,EAAuB,KAAK,iBAAiB,EAAE,0BAAuB;AAE7E,yBAAiB,4BAA4B,CAAC;IAC5C;;;;;OAKG;IACH,KAAY,SAAS,CAAC,IAAI,SAAS,SAAS,MAAM,EAAE,GAAG,SAAS,MAAM,EAAE,IAAI;QAC1E,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;QACpB,QAAQ,CAAC,MAAM,EAAE,iBAAiB,GAAG,yBAAyB,CAAC;QAC/D,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;KACrC,CAAC;IAEF,KAAY,UAAU,CAAC,IAAI,SAAS,SAAS,MAAM,EAAE,GAAG,SAAS,MAAM,EAAE,IAAI;QAC3E;;;;WAIG;QACH,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC,IAAI,CAAC,GAAG,iBAAiB,CAAC;QACnD;;;;;WAKG;QACH,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAC;KAC9B,CAAC;IAEF,KAAY,KAAK,CAAC,IAAI,SAAS,SAAS,MAAM,EAAE,GAAG,SAAS,MAAM,EAAE,IAAI;QACtE;;;;;;;;;;;;;;;;;;;WAmBG;QACH,QAAQ,CAAC,OAAO,EAAE,CAChB,IAAI,EAAE,SAAS,EACf,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,SAAS,SAAS,EAAE,KACxB,QAAQ,CAAC,IAAI,CAAC,CAAC;QAEpB;;;;;;;;WAQG;QACH,QAAQ,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,UAAU,CAAC,IAAI,CAAC,KAAK,SAAS,CAAC;KAC1D,CAAC;CACH;AAmDD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,4BAA4B;KAAI,IAAI,SAAS,SAAS,MAAM,EAAE,0BAGxE,4BAA4B,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,SAAS;;CAYtD,CAAC"}
+{"version":3,"file":"MessageGroupedParts.d.ts","names":[],"sources":["../../../../src/react/primitives/message/MessageGroupedParts.tsx"],"mappings":";;;;;;kBAiBiB,4BAAA;;AAAjB;;;;;OAOc,SAAA;IAAA,SACD,IAAA,EAAM,IAAA;IAAA,SACN,MAAA,EAAQ,iBAAA,GAAoB,yBAAA;IAAA,SAC5B,OAAA;EAAA;EAAA,KAGC,UAAA;IA2CsC;;;;;IAAA,SArCvC,IAAA,EAAM,SAAA,CAAU,IAAA,IAAQ,iBAAA;IAZvB;;;;;;IAAA,SAmBD,QAAA,EAAU,SAAA;EAAA;EAAA,KAGT,KAAA;IAhBW;;;;;;;;;;;;;;;;;;;AAsDmC;AAqF5D;;;;;;IA3IyB,SA2CZ,OAAA,GAAU,IAAA,EAAM,SAAA,cAAuB,IAAA;IAmGN;;;;;;;;;IAAA,SAxFjC,QAAA,GAAW,IAAA,EAAM,UAAA,CAAW,IAAA,MAAU,SAAA;EAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAqFtC,4BAAA;EAAA;IAA8D,OAAA;IAAA;EAAA,GAGxE,4BAAA,CAA6B,KAAA,CAAM,IAAA,IAAQ,SAAA"}

package/dist/react/primitives/message/MessageGroupedParts.js

@@ -1,75 +1,77 @@
 "use client";
-import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { MessagePartChildren } from "./MessageParts.js";
+import { GROUPBY_MEMO_KEY, buildGroupTree } from "../../utils/groupParts.js";
 import { Fragment, useMemo } from "react";
 import { useAuiState } from "@assistant-ui/store";
+import { Fragment as Fragment$1, jsx } from "react/jsx-runtime";
 import { useShallow } from "zustand/shallow";
-import { buildGroupTree, normalizeGroupKey, } from "../../utils/groupParts.js";
-import { MessagePartChildren } from "./MessageParts.js";
+//#region src/react/primitives/message/MessageGroupedParts.tsx
 const COMPLETE_STATUS = Object.freeze({ type: "complete" });
 /**
- * `children` placeholder passed for leaf-part renders. Leaf parts have no
- * inner subtree; rendering this sentinel signals the consumer wrote
- * `default: return children;` and accidentally fell through for a part —
- * surface the bug loudly instead of silently rendering nothing.
- */
+* `children` placeholder passed for leaf-part renders. Leaf parts have no
+* inner subtree; rendering this sentinel signals the consumer wrote
+* `default: return children;` and accidentally fell through for a part —
+* surface the bug loudly instead of silently rendering nothing.
+*/
 const PartChildrenSentinel = () => {
-    throw new Error("MessagePrimitive.GroupedParts: rendered `children` under a leaf " +
-        "part. `children` is only meaningful for `group-…` cases — add a " +
-        "matching case for the part type or return `null` to skip it.");
+	throw new Error("MessagePrimitive.GroupedParts: rendered `children` under a leaf part. `children` is only meaningful for `group-…` cases — add a matching case for the part type or return `null` to skip it.");
 };
 const renderNode = (node, parts, render) => {
-    if (node.type === "part") {
-        // Key by absolute part index, not structural nodeKey — prevents zombie fiber subscriptions when parts reshape (#4051).
-        return (_jsx(MessagePartChildren, { index: node.index, children: ({ part }) => render({ part, children: _jsx(PartChildrenSentinel, {}) }) }, `part-${node.index}`));
-    }
-    const status = parts[node.indices.at(-1)]?.status ?? COMPLETE_STATUS;
-    const groupPart = {
-        type: node.key,
-        status,
-        indices: node.indices,
-    };
-    return (_jsx(Fragment, { children: render({
-            part: groupPart,
-            children: (_jsx(_Fragment, { children: node.children.map((child) => renderNode(child, parts, render)) })),
-        }) }, node.nodeKey));
+	if (node.type === "part") return /* @__PURE__ */ jsx(MessagePartChildren, {
+		index: node.index,
+		children: ({ part }) => render({
+			part,
+			children: /* @__PURE__ */ jsx(PartChildrenSentinel, {})
+		})
+	}, `part-${node.index}`);
+	const status = parts[node.indices.at(-1)]?.status ?? COMPLETE_STATUS;
+	return /* @__PURE__ */ jsx(Fragment, { children: render({
+		part: {
+			type: node.key,
+			status,
+			indices: node.indices
+		},
+		children: /* @__PURE__ */ jsx(Fragment$1, { children: node.children.map((child) => renderNode(child, parts, render)) })
+	}) }, node.nodeKey);
 };
 /**
- * Groups adjacent message parts into a tree of coalesced runs and
- * renders each node — group or part — through a single `children`
- * function.
- *
- * The render function receives `{ part, children }` where `part.type`
- * is either a `"group-…"` literal (for a group, `children` is the
- * recursively-rendered subtree) or a real part type (`"text"`,
- * `"tool-call"`, …) for a leaf (`children` is a sentinel that throws
- * if rendered — use `part.type` to distinguish).
- *
- * @example
- * ```tsx
- * <MessagePrimitive.GroupedParts
- *   groupBy={(part) =>
- *     part.type === "reasoning" ? ["group-thought", "group-reasoning"] :
- *     part.type === "tool-call" ? ["group-thought", "group-tool"] :
- *     null
- *   }
- * >
- *   {({ part, children }) => {
- *     switch (part.type) {
- *       case "group-thought":   return <Thought>{children}</Thought>;
- *       case "group-reasoning": return <Reasoning>{children}</Reasoning>;
- *       case "group-tool":      return <ToolStack>{children}</ToolStack>;
- *       case "text":            return <MarkdownText />;
- *       case "tool-call":       return part.toolUI ?? <ToolFallback {...part} />;
- *       default:                return null;
- *     }
- *   }}
- * </MessagePrimitive.GroupedParts>
- * ```
- */
-export const MessagePrimitiveGroupedParts = ({ groupBy, children, }) => {
-    const parts = useAuiState(useShallow((s) => s.message.parts));
-    const tree = useMemo(() => buildGroupTree(parts.map((part, i) => normalizeGroupKey(groupBy(part, i, parts)))), [parts, groupBy]);
-    return _jsx(_Fragment, { children: tree.map((node) => renderNode(node, parts, children)) });
+* Groups adjacent message parts into a tree of coalesced runs and
+* renders each node — group or part — through a single `children`
+* function.
+*
+* The render function receives `{ part, children }` where `part.type`
+* is either a `"group-…"` literal (for a group, `children` is the
+* recursively-rendered subtree) or a real part type (`"text"`,
+* `"tool-call"`, …) for a leaf (`children` is a sentinel that throws
+* if rendered — use `part.type` to distinguish).
+*
+* @example
+* ```tsx
+* <MessagePrimitive.GroupedParts
+*   groupBy={groupPartByType({
+*     reasoning: ["group-thought", "group-reasoning"],
+*     "tool-call": ["group-thought", "group-tool"],
+*   })}
+* >
+*   {({ part, children }) => {
+*     switch (part.type) {
+*       case "group-thought":   return <Thought>{children}</Thought>;
+*       case "group-reasoning": return <Reasoning>{children}</Reasoning>;
+*       case "group-tool":      return <ToolStack>{children}</ToolStack>;
+*       case "text":            return <MarkdownText />;
+*       case "tool-call":       return part.toolUI ?? <ToolFallback {...part} />;
+*       default:                return null;
+*     }
+*   }}
+* </MessagePrimitive.GroupedParts>
+* ```
+*/
+const MessagePrimitiveGroupedParts = ({ groupBy, children }) => {
+	const parts = useAuiState(useShallow((s) => s.message.parts));
+	return /* @__PURE__ */ jsx(Fragment$1, { children: useMemo(() => buildGroupTree(parts.map((part) => groupBy(part) ?? [])), [parts, groupBy[GROUPBY_MEMO_KEY] ?? groupBy]).map((node) => renderNode(node, parts, children)) });
 };
 MessagePrimitiveGroupedParts.displayName = "MessagePrimitive.GroupedParts";
+//#endregion
+export { MessagePrimitiveGroupedParts };
+
 //# sourceMappingURL=MessageGroupedParts.js.map

package/dist/react/primitives/message/MessageGroupedParts.js.map

@@ -1 +1 @@
-{"version":3,"file":"MessageGroupedParts.js","sourceRoot":"","sources":["../../../../src/react/primitives/message/MessageGroupedParts.tsx"],"names":[],"mappings":"AAAA,YAAY,CAAC;;AAEb,OAAO,EAAE,QAAQ,EAA2B,OAAO,EAAE,MAAM,OAAO,CAAC;AACnE,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAM7C,OAAO,EACL,cAAc,EAGd,iBAAiB,GAClB,kCAA+B;AAChC,OAAO,EAAE,mBAAmB,EAA0B,0BAAuB;AAuE7E,MAAM,eAAe,GAAsB,MAAM,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC,CAAC;AAE/E;;;;;GAKG;AACH,MAAM,oBAAoB,GAAO,GAAG,EAAE;IACpC,MAAM,IAAI,KAAK,CACb,kEAAkE;QAChE,kEAAkE;QAClE,8DAA8D,CACjE,CAAC;AACJ,CAAC,CAAC;AAEF,MAAM,UAAU,GAAG,CACjB,IAAe,EACf,KAA2B,EAC3B,MAA0E,EAC/D,EAAE;IACb,IAAI,IAAI,CAAC,IAAI,KAAK,MAAM,EAAE,CAAC;QACzB,uHAAuH;QACvH,OAAO,CACL,KAAC,mBAAmB,IAA4B,KAAK,EAAE,IAAI,CAAC,KAAK,YAC9D,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAC,oBAAoB,KAAG,EAAE,CAAC,IAD3C,QAAQ,IAAI,CAAC,KAAK,EAAE,CAExB,CACvB,CAAC;IACJ,CAAC;IAED,MAAM,MAAM,GAAG,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC,CAAE,CAAC,EAAE,MAAM,IAAI,eAAe,CAAC;IACtE,MAAM,SAAS,GAAiD;QAC9D,IAAI,EAAE,IAAI,CAAC,GAAW;QACtB,MAAM;QACN,OAAO,EAAE,IAAI,CAAC,OAAO;KACtB,CAAC;IAEF,OAAO,CACL,KAAC,QAAQ,cACN,MAAM,CAAC;YACN,IAAI,EAAE,SAAS;YACf,QAAQ,EAAE,CACR,4BAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,UAAU,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC,GAAI,CACtE;SACF,CAAC,IANW,IAAI,CAAC,OAAO,CAOhB,CACZ,CAAC;AACJ,CAAC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,MAAM,CAAC,MAAM,4BAA4B,GAAG,CAAiC,EAC3E,OAAO,EACP,QAAQ,GACiC,EAAa,EAAE;IACxD,MAAM,KAAK,GAAG,WAAW,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC;IAE9D,MAAM,IAAI,GAAG,OAAO,CAClB,GAAG,EAAE,CACH,cAAc,CACZ,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,EAAE,CAAC,iBAAiB,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CACnE,EACH,CAAC,KAAK,EAAE,OAAO,CAAC,CACjB,CAAC;IAEF,OAAO,4BAAG,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,UAAU,CAAC,IAAI,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC,GAAI,CAAC;AACtE,CAAC,CAAC;AAEF,4BAA4B,CAAC,WAAW,GAAG,+BAA+B,CAAC"}
+{"version":3,"file":"MessageGroupedParts.js","names":[],"sources":["../../../../src/react/primitives/message/MessageGroupedParts.tsx"],"sourcesContent":["\"use client\";\n\nimport { Fragment, type FC, type ReactNode, useMemo } from \"react\";\nimport { useAuiState } from \"@assistant-ui/store\";\nimport { useShallow } from \"zustand/shallow\";\nimport type { PartState } from \"../../../store/scopes/part\";\nimport type {\n  MessagePartStatus,\n  ToolCallMessagePartStatus,\n} from \"../../../types/message\";\nimport {\n  buildGroupTree,\n  GROUPBY_MEMO_KEY,\n  type GroupNode,\n} from \"../../utils/groupParts\";\nimport { MessagePartChildren, type EnrichedPartState } from \"./MessageParts\";\n\nexport namespace MessagePrimitiveGroupedParts {\n  /**\n   * A coalesced group of adjacent parts. Surfaced through the same\n   * `{ part }` channel as a leaf {@link EnrichedPartState} so consumers\n   * dispatch on a single `switch (part.type)`. `type` is the group key\n   * (always `\"group-…\"`); `status` mirrors the last contained part.\n   */\n  export type GroupPart<TKey extends `group-${string}` = `group-${string}`> = {\n    readonly type: TKey;\n    readonly status: MessagePartStatus | ToolCallMessagePartStatus;\n    readonly indices: readonly number[];\n  };\n\n  export type RenderInfo<TKey extends `group-${string}` = `group-${string}`> = {\n    /**\n     * Either a coalesced group ({@link GroupPart}, identified by a\n     * `group-…` `type`) or a single enriched part. Use one switch over\n     * `part.type` to handle both.\n     */\n    readonly part: GroupPart<TKey> | EnrichedPartState;\n    /**\n     * For group nodes: the recursively-rendered subtree (subgroups +\n     * leaf parts). For leaf parts: a sentinel that throws when rendered\n     * — accidental fall-through (`default: return children;`) errors\n     * loudly instead of silently rendering nothing.\n     */\n    readonly children: ReactNode;\n  };\n\n  export type Props<TKey extends `group-${string}` = `group-${string}`> = {\n    /**\n     * Maps each part to a group-key path. Adjacent parts that share a\n     * prefix coalesce into the same group. Return `[]` (or `null`) to\n     * leave a part ungrouped.\n     *\n     * Group keys must start with `\"group-\"` so the renderer's\n     * `switch (part.type)` can tell groups apart from real part types.\n     *\n     * **Prefer {@link groupPartByType}** for the common case of mapping by\n     * `part.type` — it ships a stable memo fingerprint so the tree\n     * survives unrelated re-renders. Use an inline function only when\n     * the helper isn't expressive enough (e.g. branching on\n     * `part.toolName` or part metadata).\n     *\n     * @example\n     * ```tsx\n     * import { groupPartByType } from \"@assistant-ui/react\";\n     *\n     * <MessagePrimitive.GroupedParts\n     *   groupBy={groupPartByType({\n     *     reasoning: [\"group-thought\", \"group-reasoning\"],\n     *     \"tool-call\": [\"group-thought\", \"group-tool\"],\n     *   })}\n     * >\n     * ```\n     */\n    readonly groupBy: (part: PartState) => readonly TKey[] | null;\n\n    /**\n     * Render function called once per group node and once per leaf part.\n     * Switch on `part.type`: `\"group-…\"` cases wrap `children`; real\n     * part types (`\"text\"`, `\"tool-call\"`, …) render the part directly.\n     *\n     * Leaf parts receive the same {@link EnrichedPartState} that\n     * `<MessagePrimitive.Parts>` would produce (`toolUI`, `addResult`,\n     * `resume`, `respondToApproval`, `dataRendererUI`).\n     */\n    readonly children: (info: RenderInfo<TKey>) => ReactNode;\n  };\n}\n\nconst COMPLETE_STATUS: MessagePartStatus = Object.freeze({ type: \"complete\" });\n\n/**\n * `children` placeholder passed for leaf-part renders. Leaf parts have no\n * inner subtree; rendering this sentinel signals the consumer wrote\n * `default: return children;` and accidentally fell through for a part —\n * surface the bug loudly instead of silently rendering nothing.\n */\nconst PartChildrenSentinel: FC = () => {\n  throw new Error(\n    \"MessagePrimitive.GroupedParts: rendered `children` under a leaf \" +\n      \"part. `children` is only meaningful for `group-…` cases — add a \" +\n      \"matching case for the part type or return `null` to skip it.\",\n  );\n};\n\nconst renderNode = <TKey extends `group-${string}`>(\n  node: GroupNode,\n  parts: readonly PartState[],\n  render: (info: MessagePrimitiveGroupedParts.RenderInfo<TKey>) => ReactNode,\n): ReactNode => {\n  if (node.type === \"part\") {\n    // Key by absolute part index, not structural nodeKey — prevents zombie fiber subscriptions when parts reshape (#4051).\n    return (\n      <MessagePartChildren key={`part-${node.index}`} index={node.index}>\n        {({ part }) => render({ part, children: <PartChildrenSentinel /> })}\n      </MessagePartChildren>\n    );\n  }\n\n  const status = parts[node.indices.at(-1)!]?.status ?? COMPLETE_STATUS;\n  const groupPart: MessagePrimitiveGroupedParts.GroupPart<TKey> = {\n    type: node.key as TKey,\n    status,\n    indices: node.indices,\n  };\n\n  return (\n    <Fragment key={node.nodeKey}>\n      {render({\n        part: groupPart,\n        children: (\n          <>{node.children.map((child) => renderNode(child, parts, render))}</>\n        ),\n      })}\n    </Fragment>\n  );\n};\n\n/**\n * Groups adjacent message parts into a tree of coalesced runs and\n * renders each node — group or part — through a single `children`\n * function.\n *\n * The render function receives `{ part, children }` where `part.type`\n * is either a `\"group-…\"` literal (for a group, `children` is the\n * recursively-rendered subtree) or a real part type (`\"text\"`,\n * `\"tool-call\"`, …) for a leaf (`children` is a sentinel that throws\n * if rendered — use `part.type` to distinguish).\n *\n * @example\n * ```tsx\n * <MessagePrimitive.GroupedParts\n *   groupBy={groupPartByType({\n *     reasoning: [\"group-thought\", \"group-reasoning\"],\n *     \"tool-call\": [\"group-thought\", \"group-tool\"],\n *   })}\n * >\n *   {({ part, children }) => {\n *     switch (part.type) {\n *       case \"group-thought\":   return <Thought>{children}</Thought>;\n *       case \"group-reasoning\": return <Reasoning>{children}</Reasoning>;\n *       case \"group-tool\":      return <ToolStack>{children}</ToolStack>;\n *       case \"text\":            return <MarkdownText />;\n *       case \"tool-call\":       return part.toolUI ?? <ToolFallback {...part} />;\n *       default:                return null;\n *     }\n *   }}\n * </MessagePrimitive.GroupedParts>\n * ```\n */\nexport const MessagePrimitiveGroupedParts = <TKey extends `group-${string}`>({\n  groupBy,\n  children,\n}: MessagePrimitiveGroupedParts.Props<TKey>): ReactNode => {\n  const parts = useAuiState(useShallow((s) => s.message.parts));\n\n  // Helpers like `groupPartByType` tag the function with `GROUPBY_MEMO_KEY`\n  // (a stable string fingerprint of the helper config). When present,\n  // memo on `[parts, memoKey]` so the tree survives unrelated renders.\n  // For inline `groupBy`, fall back to recomputing each render — O(n)\n  // and cheap.\n  const memoKey = (groupBy as { [GROUPBY_MEMO_KEY]?: string })[\n    GROUPBY_MEMO_KEY\n  ];\n  const memoDep = memoKey ?? groupBy;\n  // biome-ignore lint/correctness/useExhaustiveDependencies: groupBy is captured via memoDep — either as its identity (no memoKey) or as the helper's memoKey fingerprint. Listing groupBy directly would defeat the helper-tagged memo path.\n  const tree = useMemo(\n    () => buildGroupTree(parts.map((part) => groupBy(part) ?? [])),\n    [parts, memoDep],\n  );\n\n  return <>{tree.map((node) => renderNode(node, parts, children))}</>;\n};\n\nMessagePrimitiveGroupedParts.displayName = \"MessagePrimitive.GroupedParts\";\n"],"mappings":";;;;;;;;AAwFA,MAAM,kBAAqC,OAAO,OAAO,EAAE,MAAM,WAAW,CAAC;;;;;;;AAQ7E,MAAM,6BAAiC;CACrC,MAAM,IAAI,MACR,8LAGF;AACF;AAEA,MAAM,cACJ,MACA,OACA,WACc;CACd,IAAI,KAAK,SAAS,QAEhB,OACE,oBAAC,qBAAD;EAAgD,OAAO,KAAK;aACxD,EAAE,WAAW,OAAO;GAAE;GAAM,UAAU,oBAAC,sBAAD,CAAuB,CAAA;EAAE,CAAC;CAC/C,GAFK,QAAQ,KAAK,OAElB;CAIzB,MAAM,SAAS,MAAM,KAAK,QAAQ,GAAG,EAAE,IAAK,UAAU;CAOtD,OACE,oBAAC,UAAD,EAAA,UACG,OAAO;EACN,MAAM;GARV,MAAM,KAAK;GACX;GACA,SAAS,KAAK;EAMI;EACd,UACE,oBAAA,YAAA,EAAA,UAAG,KAAK,SAAS,KAAK,UAAU,WAAW,OAAO,OAAO,MAAM,CAAC,EAAI,CAAA;CAExE,CAAC,EACO,GAPK,KAAK,OAOV;AAEd;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,MAAa,gCAAgE,EAC3E,SACA,eACyD;CACzD,MAAM,QAAQ,YAAY,YAAY,MAAM,EAAE,QAAQ,KAAK,CAAC;CAiB5D,OAAO,oBAAA,YAAA,EAAA,UALM,cACL,eAAe,MAAM,KAAK,SAAS,QAAQ,IAAI,KAAK,CAAC,CAAC,CAAC,GAC7D,CAAC,OAPc,QACf,qBAEyB,OAIV,CAGJ,EAAE,KAAK,SAAS,WAAW,MAAM,OAAO,QAAQ,CAAC,EAAI,CAAA;AACpE;AAEA,6BAA6B,cAAc"}