@assistant-ui/vue 0.0.0-stage → 0.0.1

package/dist/primitives/PartByIndexProvider.js

@@ -0,0 +1,50 @@
+import { AuiProvider } from "../AuiProvider.js";
+import { useAui } from "../useAui.js";
+import { createLastValidCache as createLastValidCache$1, createStaleReporter } from "./lastValidCache.js";
+import { computed, defineComponent, h, onScopeDispose } from "vue";
+import { AuiConfig, Derived } from "@assistant-ui/store/client";
+//#region src/primitives/PartByIndexProvider.ts
+/**
+* Scopes the subtree to the message part at `index`: descendants read the
+* part through `s.part`.
+*/
+const PartByIndexProvider = defineComponent({
+	name: "PartByIndexProvider",
+	props: { index: {
+		type: Number,
+		required: true
+	} },
+	slots: Object,
+	setup(props, { slots }) {
+		const aui = useAui();
+		let disposed = false;
+		onScopeDispose(() => {
+			disposed = true;
+		});
+		const config = computed(() => {
+			const index = props.index;
+			const cache = createLastValidCache$1(createStaleReporter({
+				name: "PartByIndexProvider",
+				index,
+				isCurrent: () => !disposed && index === props.index,
+				isValid: () => index < aui.message.getState().parts.length
+			}));
+			return AuiConfig({ part: Derived({
+				source: "message",
+				query: {
+					type: "index",
+					index
+				},
+				get: (aui) => cache.resolve(index < aui.message.getState().parts.length, () => aui.message.part({ index }))
+			}) });
+		});
+		return () => h(AuiProvider, {
+			config: config.value,
+			extends: aui
+		}, { default: () => slots.default?.() });
+	}
+});
+//#endregion
+export { PartByIndexProvider };
+
+//# sourceMappingURL=PartByIndexProvider.js.map

package/dist/primitives/PartByIndexProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PartByIndexProvider.js","names":["createLastValidCache"],"sources":["../../src/primitives/PartByIndexProvider.ts"],"sourcesContent":["import {\n  computed,\n  defineComponent,\n  h,\n  onScopeDispose,\n  type SlotsType,\n  type VNodeChild,\n} from \"vue\";\nimport { AuiConfig, Derived } from \"@assistant-ui/store/client\";\nimport type { PartMethods } from \"@assistant-ui/core/store\";\nimport { AuiProvider } from \"../AuiProvider\";\nimport { useAui } from \"../useAui\";\nimport { createLastValidCache, createStaleReporter } from \"./lastValidCache\";\n\n/**\n * Scopes the subtree to the message part at `index`: descendants read the\n * part through `s.part`.\n */\nexport const PartByIndexProvider = defineComponent({\n  name: \"PartByIndexProvider\",\n  props: {\n    index: {\n      type: Number,\n      required: true,\n    },\n  },\n  slots: Object as SlotsType<{ default?: () => VNodeChild[] }>,\n  setup(props, { slots }) {\n    const aui = useAui();\n    let disposed = false;\n    onScopeDispose(() => {\n      disposed = true;\n    });\n    const config = computed(() => {\n      const index = props.index;\n      const cache = createLastValidCache<PartMethods>(\n        createStaleReporter({\n          name: \"PartByIndexProvider\",\n          index,\n          isCurrent: () => !disposed && index === props.index,\n          isValid: () => index < aui.message.getState().parts.length,\n        }),\n      );\n      return AuiConfig({\n        part: Derived({\n          source: \"message\",\n          query: { type: \"index\", index },\n          get: (aui) =>\n            cache.resolve(index < aui.message.getState().parts.length, () =>\n              aui.message.part({ index }),\n            ),\n        }),\n      });\n    });\n    return () =>\n      h(\n        AuiProvider,\n        { config: config.value, extends: aui },\n        { default: () => slots.default?.() },\n      );\n  },\n});\n"],"mappings":";;;;;;;;;;AAkBA,MAAa,sBAAsB,gBAAgB;CACjD,MAAM;CACN,OAAO,EACL,OAAO;EACL,MAAM;EACN,UAAU;CACZ,EACF;CACA,OAAO;CACP,MAAM,OAAO,EAAE,SAAS;EACtB,MAAM,MAAM,OAAO;EACnB,IAAI,WAAW;EACf,qBAAqB;GACnB,WAAW;EACb,CAAC;EACD,MAAM,SAAS,eAAe;GAC5B,MAAM,QAAQ,MAAM;GACpB,MAAM,QAAQA,uBACZ,oBAAoB;IAClB,MAAM;IACN;IACA,iBAAiB,CAAC,YAAY,UAAU,MAAM;IAC9C,eAAe,QAAQ,IAAI,QAAQ,SAAS,CAAC,CAAC,MAAM;GACtD,CAAC,CACH;GACA,OAAO,UAAU,EACf,MAAM,QAAQ;IACZ,QAAQ;IACR,OAAO;KAAE,MAAM;KAAS;IAAM;IAC9B,MAAM,QACJ,MAAM,QAAQ,QAAQ,IAAI,QAAQ,SAAS,CAAC,CAAC,MAAM,cACjD,IAAI,QAAQ,KAAK,EAAE,MAAM,CAAC,CAC5B;GACJ,CAAC,EACH,CAAC;EACH,CAAC;EACD,aACE,EACE,aACA;GAAE,QAAQ,OAAO;GAAO,SAAS;EAAI,GACrC,EAAE,eAAe,MAAM,UAAU,EAAE,CACrC;CACJ;AACF,CAAC"}

package/dist/primitives/ThreadListItemPrimitiveRoot.d.ts

@@ -0,0 +1,7 @@
+import { type SlotsType, type VNodeChild } from "vue";
+export declare const ThreadListItemPrimitiveRoot: import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, SlotsType<{
+    default?: () => VNodeChild[];
+}>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//# sourceMappingURL=ThreadListItemPrimitiveRoot.d.ts.map

package/dist/primitives/ThreadListItemPrimitiveRoot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ThreadListItemPrimitiveRoot.d.ts","sourceRoot":"","sources":["../../src/primitives/ThreadListItemPrimitiveRoot.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,SAAS,EACd,KAAK,UAAU,EAChB,MAAM,KAAK,CAAC;AAOb,eAAO,MAAM,2BAA2B;;;cAGC,MAAM,UAAU,EAAE;yEAwCzD,CAAC"}

package/dist/primitives/ThreadListItemPrimitiveRoot.js

@@ -0,0 +1,36 @@
+import { useAuiState } from "../useAuiState.js";
+import { provideThreadListItemFocus, useThreadListCollection } from "./threadListFocusGroup.js";
+import { defineComponent, h, mergeProps } from "vue";
+//#region src/primitives/ThreadListItemPrimitiveRoot.ts
+const ThreadListItemPrimitiveRoot = defineComponent({
+	name: "ThreadListItemPrimitiveRoot",
+	inheritAttrs: false,
+	slots: Object,
+	setup(_, { attrs, slots }) {
+		const active = useAuiState((s) => s.threads.mainThreadId === s.threadListItem.id);
+		const focus = provideThreadListItemFocus();
+		const collection = useThreadListCollection();
+		const onKeydown = (event) => {
+			if (event.defaultPrevented) return;
+			const trigger = focus.trigger.value;
+			if (!trigger || event.target !== trigger || event.key !== "ArrowDown" && event.key !== "ArrowUp") return;
+			const triggers = collection?.getTriggers();
+			if (!triggers) return;
+			const next = triggers[triggers.indexOf(trigger) + (event.key === "ArrowDown" ? 1 : -1)];
+			if (!next) return;
+			next.focus();
+			event.preventDefault();
+		};
+		return () => h("div", mergeProps(attrs, {
+			...active.value && {
+				"data-active": "true",
+				"aria-current": "true"
+			},
+			onKeydown
+		}), slots.default?.());
+	}
+});
+//#endregion
+export { ThreadListItemPrimitiveRoot };
+
+//# sourceMappingURL=ThreadListItemPrimitiveRoot.js.map

package/dist/primitives/ThreadListItemPrimitiveRoot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ThreadListItemPrimitiveRoot.js","names":[],"sources":["../../src/primitives/ThreadListItemPrimitiveRoot.ts"],"sourcesContent":["import {\n  defineComponent,\n  h,\n  mergeProps,\n  type SlotsType,\n  type VNodeChild,\n} from \"vue\";\nimport { useAuiState } from \"../useAuiState\";\nimport {\n  provideThreadListItemFocus,\n  useThreadListCollection,\n} from \"./threadListFocusGroup\";\n\nexport const ThreadListItemPrimitiveRoot = defineComponent({\n  name: \"ThreadListItemPrimitiveRoot\",\n  inheritAttrs: false,\n  slots: Object as SlotsType<{ default?: () => VNodeChild[] }>,\n  setup(_, { attrs, slots }) {\n    const active = useAuiState(\n      (s) => s.threads.mainThreadId === s.threadListItem.id,\n    );\n    const focus = provideThreadListItemFocus();\n    const collection = useThreadListCollection();\n    const onKeydown = (event: KeyboardEvent) => {\n      if (event.defaultPrevented) return;\n      const trigger = focus.trigger.value;\n      if (\n        !trigger ||\n        event.target !== trigger ||\n        (event.key !== \"ArrowDown\" && event.key !== \"ArrowUp\")\n      ) {\n        return;\n      }\n      const triggers = collection?.getTriggers();\n      if (!triggers) return;\n      const next =\n        triggers[\n          triggers.indexOf(trigger) + (event.key === \"ArrowDown\" ? 1 : -1)\n        ];\n      if (!next) return;\n      next.focus();\n      event.preventDefault();\n    };\n    return () =>\n      h(\n        \"div\",\n        mergeProps(attrs, {\n          ...(active.value && {\n            \"data-active\": \"true\",\n            \"aria-current\": \"true\",\n          }),\n          onKeydown,\n        }),\n        slots.default?.(),\n      );\n  },\n});\n"],"mappings":";;;;AAaA,MAAa,8BAA8B,gBAAgB;CACzD,MAAM;CACN,cAAc;CACd,OAAO;CACP,MAAM,GAAG,EAAE,OAAO,SAAS;EACzB,MAAM,SAAS,aACZ,MAAM,EAAE,QAAQ,iBAAiB,EAAE,eAAe,EACrD;EACA,MAAM,QAAQ,2BAA2B;EACzC,MAAM,aAAa,wBAAwB;EAC3C,MAAM,aAAa,UAAyB;GAC1C,IAAI,MAAM,kBAAkB;GAC5B,MAAM,UAAU,MAAM,QAAQ;GAC9B,IACE,CAAC,WACD,MAAM,WAAW,WAChB,MAAM,QAAQ,eAAe,MAAM,QAAQ,WAE5C;GAEF,MAAM,WAAW,YAAY,YAAY;GACzC,IAAI,CAAC,UAAU;GACf,MAAM,OACJ,SACE,SAAS,QAAQ,OAAO,KAAK,MAAM,QAAQ,cAAc,IAAI;GAEjE,IAAI,CAAC,MAAM;GACX,KAAK,MAAM;GACX,MAAM,eAAe;EACvB;EACA,aACE,EACE,OACA,WAAW,OAAO;GAChB,GAAI,OAAO,SAAS;IAClB,eAAe;IACf,gBAAgB;GAClB;GACA;EACF,CAAC,GACD,MAAM,UAAU,CAClB;CACJ;AACF,CAAC"}

package/dist/primitives/ThreadListItemPrimitiveTrigger.d.ts

@@ -0,0 +1,14 @@
+import { type SlotsType, type VNodeChild } from "vue";
+/**
+ * A button that switches to the current thread-list item's thread. Carries
+ * `data-active` and `aria-current` while that thread is the main one, for
+ * standalone use; when nested under `ThreadListItemPrimitiveRoot` the root
+ * stamps them too, diverging from React's root-only pattern to keep existing
+ * standalone consumers styled.
+ */
+export declare const ThreadListItemPrimitiveTrigger: import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, SlotsType<{
+    default?: () => VNodeChild[];
+}>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//# sourceMappingURL=ThreadListItemPrimitiveTrigger.d.ts.map

package/dist/primitives/ThreadListItemPrimitiveTrigger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ThreadListItemPrimitiveTrigger.d.ts","sourceRoot":"","sources":["../../src/primitives/ThreadListItemPrimitiveTrigger.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,SAAS,EACd,KAAK,UAAU,EAChB,MAAM,KAAK,CAAC;AASb;;;;;;GAMG;AACH,eAAO,MAAM,8BAA8B;;;cAGF,MAAM,UAAU,EAAE;yEA8CzD,CAAC"}

package/dist/primitives/ThreadListItemPrimitiveTrigger.js

@@ -0,0 +1,58 @@
+import { useAuiState } from "../useAuiState.js";
+import { useAui } from "../useAui.js";
+import { isAttrDisabled } from "./attrDisabled.js";
+import { useThreadListCollection, useThreadListItemFocus } from "./threadListFocusGroup.js";
+import { defineComponent, h, mergeProps, onScopeDispose } from "vue";
+//#region src/primitives/ThreadListItemPrimitiveTrigger.ts
+/**
+* A button that switches to the current thread-list item's thread. Carries
+* `data-active` and `aria-current` while that thread is the main one, for
+* standalone use; when nested under `ThreadListItemPrimitiveRoot` the root
+* stamps them too, diverging from React's root-only pattern to keep existing
+* standalone consumers styled.
+*/
+const ThreadListItemPrimitiveTrigger = defineComponent({
+	name: "ThreadListItemPrimitiveTrigger",
+	inheritAttrs: false,
+	slots: Object,
+	setup(_, { attrs, slots }) {
+		const aui = useAui();
+		const active = useAuiState((s) => s.threads.mainThreadId === s.threadListItem.id);
+		const collection = useThreadListCollection();
+		const focus = useThreadListItemFocus();
+		const key = Symbol();
+		let trigger = null;
+		let unregister;
+		const setTrigger = (element) => {
+			const next = element instanceof HTMLButtonElement ? element : null;
+			const previous = trigger;
+			if (previous === next) return;
+			unregister?.();
+			if (focus && (next || focus.trigger.value === previous)) focus.trigger.value = next;
+			trigger = next;
+			unregister = next ? collection?.registerTrigger(key, next) : void 0;
+		};
+		onScopeDispose(() => {
+			unregister?.();
+			if (focus?.trigger.value === trigger) focus.trigger.value = null;
+		});
+		const onClick = (event) => {
+			if (event.defaultPrevented || isAttrDisabled(attrs)) return;
+			aui.threadListItem.switchTo();
+		};
+		return () => h("button", mergeProps(attrs, {
+			ref: setTrigger,
+			type: "button",
+			disabled: isAttrDisabled(attrs),
+			...active.value && {
+				"data-active": "true",
+				"aria-current": "true"
+			},
+			onClick
+		}), slots.default?.());
+	}
+});
+//#endregion
+export { ThreadListItemPrimitiveTrigger };
+
+//# sourceMappingURL=ThreadListItemPrimitiveTrigger.js.map

package/dist/primitives/ThreadListItemPrimitiveTrigger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ThreadListItemPrimitiveTrigger.js","names":[],"sources":["../../src/primitives/ThreadListItemPrimitiveTrigger.ts"],"sourcesContent":["import {\n  defineComponent,\n  h,\n  mergeProps,\n  onScopeDispose,\n  type ComponentPublicInstance,\n  type SlotsType,\n  type VNodeChild,\n} from \"vue\";\nimport { isAttrDisabled } from \"./attrDisabled\";\nimport { useAui } from \"../useAui\";\nimport { useAuiState } from \"../useAuiState\";\nimport {\n  useThreadListCollection,\n  useThreadListItemFocus,\n} from \"./threadListFocusGroup\";\n\n/**\n * A button that switches to the current thread-list item's thread. Carries\n * `data-active` and `aria-current` while that thread is the main one, for\n * standalone use; when nested under `ThreadListItemPrimitiveRoot` the root\n * stamps them too, diverging from React's root-only pattern to keep existing\n * standalone consumers styled.\n */\nexport const ThreadListItemPrimitiveTrigger = defineComponent({\n  name: \"ThreadListItemPrimitiveTrigger\",\n  inheritAttrs: false,\n  slots: Object as SlotsType<{ default?: () => VNodeChild[] }>,\n  setup(_, { attrs, slots }) {\n    const aui = useAui();\n    const active = useAuiState(\n      (s) => s.threads.mainThreadId === s.threadListItem.id,\n    );\n    const collection = useThreadListCollection();\n    const focus = useThreadListItemFocus();\n    const key = Symbol();\n    let trigger: HTMLButtonElement | null = null;\n    let unregister: (() => void) | undefined;\n    const setTrigger = (element: Element | ComponentPublicInstance | null) => {\n      const next = element instanceof HTMLButtonElement ? element : null;\n      const previous = trigger;\n      if (previous === next) return;\n      unregister?.();\n      if (focus && (next || focus.trigger.value === previous)) {\n        focus.trigger.value = next;\n      }\n      trigger = next;\n      unregister = next ? collection?.registerTrigger(key, next) : undefined;\n    };\n    onScopeDispose(() => {\n      unregister?.();\n      if (focus?.trigger.value === trigger) focus.trigger.value = null;\n    });\n    const onClick = (event: MouseEvent) => {\n      if (event.defaultPrevented || isAttrDisabled(attrs)) return;\n      aui.threadListItem.switchTo();\n    };\n    return () =>\n      h(\n        \"button\",\n        mergeProps(attrs, {\n          ref: setTrigger,\n          type: \"button\",\n          disabled: isAttrDisabled(attrs),\n          ...(active.value && {\n            \"data-active\": \"true\",\n            \"aria-current\": \"true\",\n          }),\n          onClick,\n        }),\n        slots.default?.(),\n      );\n  },\n});\n"],"mappings":";;;;;;;;;;;;;AAwBA,MAAa,iCAAiC,gBAAgB;CAC5D,MAAM;CACN,cAAc;CACd,OAAO;CACP,MAAM,GAAG,EAAE,OAAO,SAAS;EACzB,MAAM,MAAM,OAAO;EACnB,MAAM,SAAS,aACZ,MAAM,EAAE,QAAQ,iBAAiB,EAAE,eAAe,EACrD;EACA,MAAM,aAAa,wBAAwB;EAC3C,MAAM,QAAQ,uBAAuB;EACrC,MAAM,MAAM,OAAO;EACnB,IAAI,UAAoC;EACxC,IAAI;EACJ,MAAM,cAAc,YAAsD;GACxE,MAAM,OAAO,mBAAmB,oBAAoB,UAAU;GAC9D,MAAM,WAAW;GACjB,IAAI,aAAa,MAAM;GACvB,aAAa;GACb,IAAI,UAAU,QAAQ,MAAM,QAAQ,UAAU,WAC5C,MAAM,QAAQ,QAAQ;GAExB,UAAU;GACV,aAAa,OAAO,YAAY,gBAAgB,KAAK,IAAI,IAAI,KAAA;EAC/D;EACA,qBAAqB;GACnB,aAAa;GACb,IAAI,OAAO,QAAQ,UAAU,SAAS,MAAM,QAAQ,QAAQ;EAC9D,CAAC;EACD,MAAM,WAAW,UAAsB;GACrC,IAAI,MAAM,oBAAoB,eAAe,KAAK,GAAG;GACrD,IAAI,eAAe,SAAS;EAC9B;EACA,aACE,EACE,UACA,WAAW,OAAO;GAChB,KAAK;GACL,MAAM;GACN,UAAU,eAAe,KAAK;GAC9B,GAAI,OAAO,SAAS;IAClB,eAAe;IACf,gBAAgB;GAClB;GACA;EACF,CAAC,GACD,MAAM,UAAU,CAClB;CACJ;AACF,CAAC"}

package/dist/primitives/ThreadListPrimitiveRoot.d.ts

@@ -0,0 +1,7 @@
+import { type SlotsType, type VNodeChild } from "vue";
+export declare const ThreadListPrimitiveRoot: import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, SlotsType<{
+    default?: () => VNodeChild[];
+}>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//# sourceMappingURL=ThreadListPrimitiveRoot.d.ts.map

package/dist/primitives/ThreadListPrimitiveRoot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ThreadListPrimitiveRoot.d.ts","sourceRoot":"","sources":["../../src/primitives/ThreadListPrimitiveRoot.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,SAAS,EACd,KAAK,UAAU,EAChB,MAAM,KAAK,CAAC;AAGb,eAAO,MAAM,uBAAuB;;;cAGK,MAAM,UAAU,EAAE;yEAKzD,CAAC"}

package/dist/primitives/ThreadListPrimitiveRoot.js

@@ -0,0 +1,16 @@
+import { provideThreadListCollection } from "./threadListFocusGroup.js";
+import { defineComponent, h, mergeProps } from "vue";
+//#region src/primitives/ThreadListPrimitiveRoot.ts
+const ThreadListPrimitiveRoot = defineComponent({
+	name: "ThreadListPrimitiveRoot",
+	inheritAttrs: false,
+	slots: Object,
+	setup(_, { attrs, slots }) {
+		provideThreadListCollection();
+		return () => h("div", mergeProps(attrs), slots.default?.());
+	}
+});
+//#endregion
+export { ThreadListPrimitiveRoot };
+
+//# sourceMappingURL=ThreadListPrimitiveRoot.js.map

package/dist/primitives/ThreadListPrimitiveRoot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ThreadListPrimitiveRoot.js","names":[],"sources":["../../src/primitives/ThreadListPrimitiveRoot.ts"],"sourcesContent":["import {\n  defineComponent,\n  h,\n  mergeProps,\n  type SlotsType,\n  type VNodeChild,\n} from \"vue\";\nimport { provideThreadListCollection } from \"./threadListFocusGroup\";\n\nexport const ThreadListPrimitiveRoot = defineComponent({\n  name: \"ThreadListPrimitiveRoot\",\n  inheritAttrs: false,\n  slots: Object as SlotsType<{ default?: () => VNodeChild[] }>,\n  setup(_, { attrs, slots }) {\n    provideThreadListCollection();\n    return () => h(\"div\", mergeProps(attrs), slots.default?.());\n  },\n});\n"],"mappings":";;;AASA,MAAa,0BAA0B,gBAAgB;CACrD,MAAM;CACN,cAAc;CACd,OAAO;CACP,MAAM,GAAG,EAAE,OAAO,SAAS;EACzB,4BAA4B;EAC5B,aAAa,EAAE,OAAO,WAAW,KAAK,GAAG,MAAM,UAAU,CAAC;CAC5D;AACF,CAAC"}

package/dist/primitives/ThreadPrimitiveMessages.d.ts

@@ -0,0 +1,23 @@
+import { type SlotsType, type VNodeChild } from "vue";
+/**
+ * Renders the default slot once per message in the current thread, each
+ * instance scoped to its message through {@link MessageByIdProvider} and
+ * keyed by the message id: an edit or reload that replaces the occupant of a
+ * slot remounts that row, so `<TransitionGroup>` and per-row component state
+ * follow message identity. The empty optimistic placeholder that precedes a
+ * response is its own identity, so the arrival of the real assistant message
+ * remounts that one row (a leave/enter pair under `<TransitionGroup>`).
+ *
+ * @example
+ * ```html
+ * <ThreadPrimitiveMessages>
+ *   <ChatMessage />
+ * </ThreadPrimitiveMessages>
+ * ```
+ */
+export declare const ThreadPrimitiveMessages: import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[], {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, SlotsType<{
+    default?: () => VNodeChild[];
+}>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//# sourceMappingURL=ThreadPrimitiveMessages.d.ts.map

package/dist/primitives/ThreadPrimitiveMessages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ThreadPrimitiveMessages.d.ts","sourceRoot":"","sources":["../../src/primitives/ThreadPrimitiveMessages.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,KAAK,SAAS,EAAE,KAAK,UAAU,EAAE,MAAM,KAAK,CAAC;AAM1E;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,uBAAuB;;;cAEK,MAAM,UAAU,EAAE;yEAezD,CAAC"}

package/dist/primitives/ThreadPrimitiveMessages.js

@@ -0,0 +1,37 @@
+import { useAuiState } from "../useAuiState.js";
+import { MessageByIdProvider } from "./MessageByIdProvider.js";
+import { useStableKeys } from "./stableKeys.js";
+import { defineComponent, h } from "vue";
+//#region src/primitives/ThreadPrimitiveMessages.ts
+/**
+* Renders the default slot once per message in the current thread, each
+* instance scoped to its message through {@link MessageByIdProvider} and
+* keyed by the message id: an edit or reload that replaces the occupant of a
+* slot remounts that row, so `<TransitionGroup>` and per-row component state
+* follow message identity. The empty optimistic placeholder that precedes a
+* response is its own identity, so the arrival of the real assistant message
+* remounts that one row (a leave/enter pair under `<TransitionGroup>`).
+*
+* @example
+* ```html
+* <ThreadPrimitiveMessages>
+*   <ChatMessage />
+* </ThreadPrimitiveMessages>
+* ```
+*/
+const ThreadPrimitiveMessages = defineComponent({
+	name: "ThreadPrimitiveMessages",
+	slots: Object,
+	setup(_, { slots }) {
+		const messages = useAuiState((s) => s.thread.messages);
+		const ids = useStableKeys(() => messages.value.map((message) => message.id));
+		return () => ids.value.map((id) => h(MessageByIdProvider, {
+			id,
+			key: id
+		}, { default: () => slots.default?.() }));
+	}
+});
+//#endregion
+export { ThreadPrimitiveMessages };
+
+//# sourceMappingURL=ThreadPrimitiveMessages.js.map

package/dist/primitives/ThreadPrimitiveMessages.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ThreadPrimitiveMessages.js","names":[],"sources":["../../src/primitives/ThreadPrimitiveMessages.ts"],"sourcesContent":["import { defineComponent, h, type SlotsType, type VNodeChild } from \"vue\";\nimport type {} from \"@assistant-ui/core/store\";\nimport { useAuiState } from \"../useAuiState\";\nimport { MessageByIdProvider } from \"./MessageByIdProvider\";\nimport { useStableKeys } from \"./stableKeys\";\n\n/**\n * Renders the default slot once per message in the current thread, each\n * instance scoped to its message through {@link MessageByIdProvider} and\n * keyed by the message id: an edit or reload that replaces the occupant of a\n * slot remounts that row, so `<TransitionGroup>` and per-row component state\n * follow message identity. The empty optimistic placeholder that precedes a\n * response is its own identity, so the arrival of the real assistant message\n * remounts that one row (a leave/enter pair under `<TransitionGroup>`).\n *\n * @example\n * ```html\n * <ThreadPrimitiveMessages>\n *   <ChatMessage />\n * </ThreadPrimitiveMessages>\n * ```\n */\nexport const ThreadPrimitiveMessages = defineComponent({\n  name: \"ThreadPrimitiveMessages\",\n  slots: Object as SlotsType<{ default?: () => VNodeChild[] }>,\n  setup(_, { slots }) {\n    const messages = useAuiState((s) => s.thread.messages);\n    const ids = useStableKeys(() =>\n      messages.value.map((message) => message.id),\n    );\n    return () =>\n      ids.value.map((id) =>\n        h(\n          MessageByIdProvider,\n          { id, key: id },\n          { default: () => slots.default?.() },\n        ),\n      );\n  },\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAsBA,MAAa,0BAA0B,gBAAgB;CACrD,MAAM;CACN,OAAO;CACP,MAAM,GAAG,EAAE,SAAS;EAClB,MAAM,WAAW,aAAa,MAAM,EAAE,OAAO,QAAQ;EACrD,MAAM,MAAM,oBACV,SAAS,MAAM,KAAK,YAAY,QAAQ,EAAE,CAC5C;EACA,aACE,IAAI,MAAM,KAAK,OACb,EACE,qBACA;GAAE;GAAI,KAAK;EAAG,GACd,EAAE,eAAe,MAAM,UAAU,EAAE,CACrC,CACF;CACJ;AACF,CAAC"}

package/dist/primitives/ThreadPrimitiveScrollToBottom.d.ts

@@ -0,0 +1,25 @@
+import { type PropType, type SlotsType, type VNodeChild } from "vue";
+export declare const clearScrollToBottomWarningForTesting: () => void;
+/**
+ * A button that scrolls the surrounding {@link ThreadPrimitiveViewport} to
+ * the bottom. Disabled while the viewport is already at the bottom, or when
+ * no viewport provides the channel.
+ */
+export declare const ThreadPrimitiveScrollToBottom: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    behavior: {
+        type: PropType<ScrollBehavior>;
+        default: string;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    behavior: {
+        type: PropType<ScrollBehavior>;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    behavior: ScrollBehavior;
+}, SlotsType<{
+    default?: () => VNodeChild[];
+}>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//# sourceMappingURL=ThreadPrimitiveScrollToBottom.d.ts.map

package/dist/primitives/ThreadPrimitiveScrollToBottom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ThreadPrimitiveScrollToBottom.d.ts","sourceRoot":"","sources":["../../src/primitives/ThreadPrimitiveScrollToBottom.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,QAAQ,EACb,KAAK,SAAS,EACd,KAAK,UAAU,EAChB,MAAM,KAAK,CAAC;AAOb,eAAO,MAAM,oCAAoC,YAEhD,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,6BAA6B;;cAKpB,QAAQ,CAAC,cAAc,CAAC;;;;;;;cAAxB,QAAQ,CAAC,cAAc,CAAC;;;;;;cAIL,MAAM,UAAU,EAAE;yEA+BzD,CAAC"}

package/dist/primitives/ThreadPrimitiveScrollToBottom.js

@@ -0,0 +1,43 @@
+import { viewportInjectionKey } from "./viewportContext.js";
+import { isAttrDisabled } from "./attrDisabled.js";
+import { defineComponent, h, inject, mergeProps } from "vue";
+import { isDevelopment } from "@assistant-ui/core/store/internal";
+//#region src/primitives/ThreadPrimitiveScrollToBottom.ts
+let warnedOutsideViewport = false;
+const clearScrollToBottomWarningForTesting = () => {
+	warnedOutsideViewport = false;
+};
+/**
+* A button that scrolls the surrounding {@link ThreadPrimitiveViewport} to
+* the bottom. Disabled while the viewport is already at the bottom, or when
+* no viewport provides the channel.
+*/
+const ThreadPrimitiveScrollToBottom = defineComponent({
+	name: "ThreadPrimitiveScrollToBottom",
+	inheritAttrs: false,
+	props: { behavior: {
+		type: String,
+		default: "auto"
+	} },
+	slots: Object,
+	setup(props, { attrs, slots }) {
+		const viewport = inject(viewportInjectionKey, null);
+		if (isDevelopment && !viewport && !warnedOutsideViewport) {
+			warnedOutsideViewport = true;
+			console.warn("ThreadPrimitiveScrollToBottom: no surrounding ThreadPrimitiveViewport provides the scroll channel; the button stays disabled. Place it inside the viewport.");
+		}
+		const onClick = (event) => {
+			if (event.defaultPrevented || !viewport || viewport.isAtBottom.value || isAttrDisabled(attrs)) return;
+			viewport.scrollToBottom(props.behavior);
+		};
+		return () => h("button", mergeProps(attrs, {
+			type: "button",
+			disabled: !viewport || viewport.isAtBottom.value || isAttrDisabled(attrs),
+			onClick
+		}), slots.default?.());
+	}
+});
+//#endregion
+export { ThreadPrimitiveScrollToBottom, clearScrollToBottomWarningForTesting };
+
+//# sourceMappingURL=ThreadPrimitiveScrollToBottom.js.map

package/dist/primitives/ThreadPrimitiveScrollToBottom.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ThreadPrimitiveScrollToBottom.js","names":[],"sources":["../../src/primitives/ThreadPrimitiveScrollToBottom.ts"],"sourcesContent":["import {\n  defineComponent,\n  h,\n  inject,\n  mergeProps,\n  type PropType,\n  type SlotsType,\n  type VNodeChild,\n} from \"vue\";\nimport { isDevelopment } from \"@assistant-ui/core/store/internal\";\nimport { isAttrDisabled } from \"./attrDisabled\";\nimport { viewportInjectionKey } from \"./viewportContext\";\n\nlet warnedOutsideViewport = false;\n\nexport const clearScrollToBottomWarningForTesting = () => {\n  warnedOutsideViewport = false;\n};\n\n/**\n * A button that scrolls the surrounding {@link ThreadPrimitiveViewport} to\n * the bottom. Disabled while the viewport is already at the bottom, or when\n * no viewport provides the channel.\n */\nexport const ThreadPrimitiveScrollToBottom = defineComponent({\n  name: \"ThreadPrimitiveScrollToBottom\",\n  inheritAttrs: false,\n  props: {\n    behavior: {\n      type: String as PropType<ScrollBehavior>,\n      default: \"auto\",\n    },\n  },\n  slots: Object as SlotsType<{ default?: () => VNodeChild[] }>,\n  setup(props, { attrs, slots }) {\n    const viewport = inject(viewportInjectionKey, null);\n    if (isDevelopment && !viewport && !warnedOutsideViewport) {\n      warnedOutsideViewport = true;\n      console.warn(\n        \"ThreadPrimitiveScrollToBottom: no surrounding ThreadPrimitiveViewport provides the scroll channel; the button stays disabled. Place it inside the viewport.\",\n      );\n    }\n    const onClick = (event: MouseEvent) => {\n      if (\n        event.defaultPrevented ||\n        !viewport ||\n        viewport.isAtBottom.value ||\n        isAttrDisabled(attrs)\n      )\n        return;\n      viewport.scrollToBottom(props.behavior);\n    };\n    return () =>\n      h(\n        \"button\",\n        mergeProps(attrs, {\n          type: \"button\",\n          disabled:\n            !viewport || viewport.isAtBottom.value || isAttrDisabled(attrs),\n          onClick,\n        }),\n        slots.default?.(),\n      );\n  },\n});\n"],"mappings":";;;;;AAaA,IAAI,wBAAwB;AAE5B,MAAa,6CAA6C;CACxD,wBAAwB;AAC1B;;;;;;AAOA,MAAa,gCAAgC,gBAAgB;CAC3D,MAAM;CACN,cAAc;CACd,OAAO,EACL,UAAU;EACR,MAAM;EACN,SAAS;CACX,EACF;CACA,OAAO;CACP,MAAM,OAAO,EAAE,OAAO,SAAS;EAC7B,MAAM,WAAW,OAAO,sBAAsB,IAAI;EAClD,IAAI,iBAAiB,CAAC,YAAY,CAAC,uBAAuB;GACxD,wBAAwB;GACxB,QAAQ,KACN,6JACF;EACF;EACA,MAAM,WAAW,UAAsB;GACrC,IACE,MAAM,oBACN,CAAC,YACD,SAAS,WAAW,SACpB,eAAe,KAAK,GAEpB;GACF,SAAS,eAAe,MAAM,QAAQ;EACxC;EACA,aACE,EACE,UACA,WAAW,OAAO;GAChB,MAAM;GACN,UACE,CAAC,YAAY,SAAS,WAAW,SAAS,eAAe,KAAK;GAChE;EACF,CAAC,GACD,MAAM,UAAU,CAClB;CACJ;AACF,CAAC"}

package/dist/primitives/ThreadPrimitiveViewport.d.ts

@@ -0,0 +1,57 @@
+import { type SlotsType, type VNodeChild } from "vue";
+/**
+ * A scrollable container that keeps the thread pinned to the bottom: content
+ * growth scrolls back down while the user sits at the bottom, a run start
+ * scrolls down, and scrolling up unpins until the user returns to the bottom.
+ * The four options mirror the React hook and are independent: `autoScroll`
+ * covers follow-on-content-growth, and the other three gate the
+ * first-messages, run-start, and thread-switch scrolls. Provides the
+ * scroll-to-bottom channel that {@link ThreadPrimitiveScrollToBottom} drives;
+ * the React viewport's top-anchor system stays in the React viewport store
+ * and is not ported.
+ */
+export declare const ThreadPrimitiveViewport: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    autoScroll: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    scrollToBottomOnInitialize: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    scrollToBottomOnRunStart: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    scrollToBottomOnThreadSwitch: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    autoScroll: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    scrollToBottomOnInitialize: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    scrollToBottomOnRunStart: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    scrollToBottomOnThreadSwitch: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    autoScroll: boolean;
+    scrollToBottomOnInitialize: boolean;
+    scrollToBottomOnRunStart: boolean;
+    scrollToBottomOnThreadSwitch: boolean;
+}, SlotsType<{
+    default?: () => VNodeChild[];
+}>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//# sourceMappingURL=ThreadPrimitiveViewport.d.ts.map

package/dist/primitives/ThreadPrimitiveViewport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ThreadPrimitiveViewport.d.ts","sourceRoot":"","sources":["../../src/primitives/ThreadPrimitiveViewport.ts"],"names":[],"mappings":"AAAA,OAAO,EAQL,KAAK,SAAS,EACd,KAAK,UAAU,EAChB,MAAM,KAAK,CAAC;AAYb;;;;;;;;;;GAUG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAoBK,MAAM,UAAU,EAAE;yEAmLzD,CAAC"}

package/dist/primitives/ThreadPrimitiveViewport.js

@@ -0,0 +1,174 @@
+import { useAuiState } from "../useAuiState.js";
+import { useAuiEvent } from "../useAuiEvent.js";
+import { viewportInjectionKey } from "./viewportContext.js";
+import { defineComponent, h, onMounted, onScopeDispose, provide, shallowRef, watch } from "vue";
+import { isUserScrollUp, isViewportAtBottom, observeContentResize, viewportOverflows } from "@assistant-ui/store/client";
+//#region src/primitives/ThreadPrimitiveViewport.ts
+/**
+* A scrollable container that keeps the thread pinned to the bottom: content
+* growth scrolls back down while the user sits at the bottom, a run start
+* scrolls down, and scrolling up unpins until the user returns to the bottom.
+* The four options mirror the React hook and are independent: `autoScroll`
+* covers follow-on-content-growth, and the other three gate the
+* first-messages, run-start, and thread-switch scrolls. Provides the
+* scroll-to-bottom channel that {@link ThreadPrimitiveScrollToBottom} drives;
+* the React viewport's top-anchor system stays in the React viewport store
+* and is not ported.
+*/
+const ThreadPrimitiveViewport = defineComponent({
+	name: "ThreadPrimitiveViewport",
+	props: {
+		autoScroll: {
+			type: Boolean,
+			default: true
+		},
+		scrollToBottomOnInitialize: {
+			type: Boolean,
+			default: true
+		},
+		scrollToBottomOnRunStart: {
+			type: Boolean,
+			default: true
+		},
+		scrollToBottomOnThreadSwitch: {
+			type: Boolean,
+			default: true
+		}
+	},
+	slots: Object,
+	setup(props, { slots }) {
+		const divRef = shallowRef(null);
+		const contentInset = shallowRef(0);
+		const contentInsetEntries = /* @__PURE__ */ new Map();
+		let intent = null;
+		const isAtBottom = shallowRef(true);
+		let lastScrollTop = 0;
+		let lastScrollHeight = 0;
+		let lastObservedScrollHeight = 0;
+		let lastObservedClientHeight = 0;
+		let frame = null;
+		const scrollToBottom = (behavior) => {
+			const div = divRef.value;
+			if (!div) return;
+			intent = behavior;
+			div.scrollTo?.({
+				top: div.scrollHeight,
+				behavior
+			});
+		};
+		const scheduleScrollToBottom = (behavior) => {
+			intent = behavior;
+			if (typeof requestAnimationFrame === "undefined") return;
+			if (frame !== null) cancelAnimationFrame(frame);
+			frame = requestAnimationFrame(() => {
+				frame = null;
+				scrollToBottom(behavior);
+			});
+		};
+		const handleScroll = () => {
+			const div = divRef.value;
+			if (!div) return;
+			const newIsAtBottom = isViewportAtBottom(div, contentInset.value);
+			if (!(!newIsAtBottom && lastScrollTop < div.scrollTop)) {
+				if (newIsAtBottom) {
+					if (viewportOverflows(div, contentInset.value)) intent = null;
+				} else if (isUserScrollUp({
+					scrollTop: lastScrollTop,
+					scrollHeight: lastScrollHeight
+				}, div)) intent = null;
+				if (newIsAtBottom || intent === null) isAtBottom.value = newIsAtBottom;
+			}
+			lastScrollTop = div.scrollTop;
+			lastScrollHeight = div.scrollHeight;
+		};
+		const updateContentInset = () => {
+			let total = 0;
+			for (const height of contentInsetEntries.values()) total += height;
+			if (contentInset.value === total) return;
+			const grew = total > contentInset.value;
+			contentInset.value = total;
+			if (grew) {
+				if (intent) scrollToBottom(intent);
+				else if (props.autoScroll && isAtBottom.value) scrollToBottom("instant");
+			}
+			handleScroll();
+		};
+		const registerContentInset = () => {
+			const id = Symbol();
+			contentInsetEntries.set(id, 0);
+			return {
+				setHeight: (height) => {
+					if (contentInsetEntries.get(id) === height) return;
+					contentInsetEntries.set(id, height);
+					updateContentInset();
+				},
+				unregister: () => {
+					if (!contentInsetEntries.delete(id)) return;
+					updateContentInset();
+				}
+			};
+		};
+		const onContentResize = () => {
+			const div = divRef.value;
+			if (!div) return;
+			const { scrollHeight, clientHeight } = div;
+			if (scrollHeight === lastObservedScrollHeight && clientHeight === lastObservedClientHeight) return;
+			lastObservedScrollHeight = scrollHeight;
+			lastObservedClientHeight = clientHeight;
+			if (intent) scrollToBottom(intent);
+			else if (props.autoScroll && isAtBottom.value) scrollToBottom("instant");
+			handleScroll();
+		};
+		const onPointerdown = () => {
+			intent = null;
+			if (frame !== null) {
+				cancelAnimationFrame(frame);
+				frame = null;
+			}
+		};
+		let disconnect;
+		onMounted(() => {
+			const div = divRef.value;
+			if (!div) return;
+			disconnect = observeContentResize(div, onContentResize);
+		});
+		onScopeDispose(() => {
+			disconnect?.();
+			if (frame !== null) cancelAnimationFrame(frame);
+		});
+		const hasMessages = useAuiState((s) => s.thread.messages.length > 0);
+		let initialized = false;
+		watch([hasMessages, () => props.scrollToBottomOnInitialize], ([has, enabled]) => {
+			if (!has) {
+				initialized = false;
+				return;
+			}
+			if (!enabled || initialized) return;
+			initialized = true;
+			if (intent !== null) return;
+			scheduleScrollToBottom("instant");
+		}, { immediate: true });
+		useAuiEvent("thread.runStart", () => {
+			if (!props.scrollToBottomOnRunStart) return;
+			scheduleScrollToBottom("auto");
+		});
+		useAuiEvent("threads.selectionChanged", () => {
+			if (!props.scrollToBottomOnThreadSwitch) return;
+			scheduleScrollToBottom("instant");
+		});
+		provide(viewportInjectionKey, {
+			isAtBottom,
+			scrollToBottom: (behavior = "auto") => scrollToBottom(behavior),
+			registerContentInset
+		});
+		return () => h("div", {
+			ref: divRef,
+			onScroll: handleScroll,
+			onPointerdown
+		}, slots.default?.());
+	}
+});
+//#endregion
+export { ThreadPrimitiveViewport };
+
+//# sourceMappingURL=ThreadPrimitiveViewport.js.map