@aparte/vue 0.2.0-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 aparté
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,34 @@
+# @aparte/vue
+
+Vue 3.5+ wrapper for [aparté](https://github.com/apartejs/aparte) — an ergonomic `<AparteChat>`
+component plus composables (`useAparteChat`, `useAparteClient`, `useConversationManager`) over the
+framework-agnostic web components in `@aparte/core`.
+
+```bash
+npm install @aparte/vue @aparte/core vue
+```
+
+```vue
+<script setup lang="ts">
+import { AparteChat, useAparteChat } from '@aparte/vue';
+import '@aparte/core/styles.css';
+
+const chat = useAparteChat();
+</script>
+
+<template>
+  <AparteChat
+    :ref="chat.chatRef"
+    :messages="chat.messages.value"
+    @messages-change="chat.onMessagesChange"
+  />
+</template>
+```
+
+The user's message is appended automatically on send — don't add it yourself. `@message-sent` is
+optional and only for side-effects (scroll, analytics).
+
+`@aparte/core` and `vue` are **peer dependencies**. For any `<aparte-*>` element without a dedicated
+component, the generic `<AparteUi name="aparte-…" />` escape hatch mounts it.
+
+> ESM-only. See the docs for the full API. Part of the aparté monorepo.

package/dist/components/AparteChat.vue.d.ts

@@ -0,0 +1,380 @@
+import { type AparteConfigClass } from '@aparte/core';
+import type { AparteMessage, AparteSegment, AparteSendEventDetail, AparteActionEventDetail } from '../types.js';
+interface Props {
+    /** Optional: omit for an uncontrolled chat (defaults to []); use `v-model:messages` to control. */
+    messages?: AparteMessage[];
+    placeholder?: string;
+    disabled?: boolean;
+    isTyping?: boolean;
+    typingText?: string;
+    /** When false, Shift+Enter submits and a bare Enter inserts a newline. */
+    submitOnEnter?: boolean;
+    /** Freeze viewport spacer recalculation for this many ms after a conv swap. */
+    layoutTransitionMs?: number;
+    /**
+     * Opt in to the "centered composer when empty" layout: the composer sits
+     * vertically centered with the `empty-state` slot above it while the list is
+     * empty, then slides to the bottom on the first message (~0.3s). Off by
+     * default — additive (adds the `--auto-center` modifier + a `data-aparte-empty`
+     * attribute the shipped `aparte.css` recipe keys off).
+     */
+    centerWhenEmpty?: boolean;
+    /** Active conversation id (loads/persists via the registered ConversationManager). */
+    conversationId?: string | null;
+    /**
+     * Instance {@link AparteConfigClass} for this chat. When set, aparté components
+     * inside resolve THIS config instead of the global `AparteConfig` singleton, so
+     * several independently-configured chats can coexist on one page. Omit for the
+     * global config. Read once when the host mounts.
+     */
+    config?: AparteConfigClass;
+}
+declare var __VLS_7: {}, __VLS_9: {
+    message: {
+        id: string;
+        role: import("@aparte/core").AparteBubbleRole;
+        content?: string | undefined;
+        segments?: ({
+            type: "tool_call";
+            toolCall: {
+                id: string;
+                name: string;
+                input: Record<string, unknown>;
+            };
+            status: "pending" | "resolved" | "aborted" | "awaiting-approval" | "rejected";
+            result?: string | undefined;
+            id: string;
+            isStreaming?: boolean | undefined;
+        } | {
+            type: "text";
+            content: string;
+            id: string;
+            isStreaming?: boolean | undefined;
+        } | {
+            type: "thinking";
+            content: string;
+            collapsed?: boolean | undefined;
+            label?: string | undefined;
+            id: string;
+            isStreaming?: boolean | undefined;
+        } | {
+            type: "code";
+            content: string;
+            language?: string | undefined;
+            filename?: string | undefined;
+            showLineNumbers?: boolean | undefined;
+            id: string;
+            isStreaming?: boolean | undefined;
+        } | {
+            type: "diff";
+            filename?: string | undefined;
+            hunks: {
+                oldStart: number;
+                newStart: number;
+                lines: {
+                    type: "add" | "remove" | "context";
+                    content: string;
+                }[];
+            }[];
+            id: string;
+            isStreaming?: boolean | undefined;
+        } | {
+            type: "terminal";
+            command?: string | undefined;
+            output?: string | undefined;
+            exitCode?: number | undefined;
+            isRunning?: boolean | undefined;
+            id: string;
+            isStreaming?: boolean | undefined;
+        } | {
+            type: "file-tree";
+            files: {
+                name: string;
+                path: string;
+                type: "file" | "directory";
+                children?: /*elided*/ any[] | undefined;
+                status?: "added" | "modified" | "deleted" | undefined;
+            }[];
+            title?: string | undefined;
+            id: string;
+            isStreaming?: boolean | undefined;
+        } | {
+            type: "image";
+            url: string;
+            alt?: string | undefined;
+            caption?: string | undefined;
+            id: string;
+            isStreaming?: boolean | undefined;
+        } | {
+            type: "preview";
+            url: string;
+            title?: string | undefined;
+            height?: number | undefined;
+            id: string;
+            isStreaming?: boolean | undefined;
+        } | {
+            type: "error";
+            content: string;
+            details?: string | undefined;
+            stack?: string | undefined;
+            id: string;
+            isStreaming?: boolean | undefined;
+        } | {
+            type: "progress";
+            label: string;
+            percent?: number | undefined;
+            status?: "pending" | "running" | "complete" | "error" | undefined;
+            id: string;
+            isStreaming?: boolean | undefined;
+        } | {
+            type: "custom";
+            subType: string;
+            data?: unknown;
+            fallback?: string | undefined;
+            id: string;
+            isStreaming?: boolean | undefined;
+        } | {
+            type: "artifact";
+            mimeType: string;
+            artifactType: string;
+            title?: string | undefined;
+            content: string;
+            inline?: boolean | undefined;
+            id: string;
+            isStreaming?: boolean | undefined;
+        } | {
+            type: "pipeline-waiting";
+            id: string;
+            isStreaming?: boolean | undefined;
+        })[] | undefined;
+        timestamp: number;
+        isStreaming?: boolean | undefined;
+        status?: import("@aparte/core").AparteStatus | undefined;
+        attachments?: {
+            id: string;
+            name: string;
+            type: string;
+            url: string;
+            size?: number | undefined;
+            thumbnailUrl?: string | undefined;
+            metadata?: Record<string, unknown> | undefined;
+            blob?: {
+                readonly size: number;
+                readonly type: string;
+                arrayBuffer: () => Promise<ArrayBuffer>;
+                bytes: () => Promise<Uint8Array>;
+                slice: (start?: number, end?: number, contentType?: string) => Blob;
+                stream: () => ReadableStream<Uint8Array>;
+                text: () => Promise<string>;
+            } | undefined;
+        }[] | undefined;
+        usage?: {
+            inputTokens: number;
+            outputTokens: number;
+            totalTokens?: number | undefined;
+            cacheReadTokens?: number | undefined;
+            durationMs?: number | undefined;
+            ttftMs?: number | undefined;
+            decodeMs?: number | undefined;
+            decodeTokens?: number | undefined;
+            wallMs?: number | undefined;
+            modelId?: string | undefined;
+            device?: string | undefined;
+            phases?: /*elided*/ any[] | undefined;
+        } | undefined;
+        branches?: {
+            id: string;
+            content?: string | undefined;
+            segments?: ({
+                type: "tool_call";
+                toolCall: {
+                    id: string;
+                    name: string;
+                    input: Record<string, unknown>;
+                };
+                status: "pending" | "resolved" | "aborted" | "awaiting-approval" | "rejected";
+                result?: string | undefined;
+                id: string;
+                isStreaming?: boolean | undefined;
+            } | {
+                type: "text";
+                content: string;
+                id: string;
+                isStreaming?: boolean | undefined;
+            } | {
+                type: "thinking";
+                content: string;
+                collapsed?: boolean | undefined;
+                label?: string | undefined;
+                id: string;
+                isStreaming?: boolean | undefined;
+            } | {
+                type: "code";
+                content: string;
+                language?: string | undefined;
+                filename?: string | undefined;
+                showLineNumbers?: boolean | undefined;
+                id: string;
+                isStreaming?: boolean | undefined;
+            } | {
+                type: "diff";
+                filename?: string | undefined;
+                hunks: {
+                    oldStart: number;
+                    newStart: number;
+                    lines: {
+                        type: "add" | "remove" | "context";
+                        content: string;
+                    }[];
+                }[];
+                id: string;
+                isStreaming?: boolean | undefined;
+            } | {
+                type: "terminal";
+                command?: string | undefined;
+                output?: string | undefined;
+                exitCode?: number | undefined;
+                isRunning?: boolean | undefined;
+                id: string;
+                isStreaming?: boolean | undefined;
+            } | {
+                type: "file-tree";
+                files: {
+                    name: string;
+                    path: string;
+                    type: "file" | "directory";
+                    children?: /*elided*/ any[] | undefined;
+                    status?: "added" | "modified" | "deleted" | undefined;
+                }[];
+                title?: string | undefined;
+                id: string;
+                isStreaming?: boolean | undefined;
+            } | {
+                type: "image";
+                url: string;
+                alt?: string | undefined;
+                caption?: string | undefined;
+                id: string;
+                isStreaming?: boolean | undefined;
+            } | {
+                type: "preview";
+                url: string;
+                title?: string | undefined;
+                height?: number | undefined;
+                id: string;
+                isStreaming?: boolean | undefined;
+            } | {
+                type: "error";
+                content: string;
+                details?: string | undefined;
+                stack?: string | undefined;
+                id: string;
+                isStreaming?: boolean | undefined;
+            } | {
+                type: "progress";
+                label: string;
+                percent?: number | undefined;
+                status?: "pending" | "running" | "complete" | "error" | undefined;
+                id: string;
+                isStreaming?: boolean | undefined;
+            } | {
+                type: "custom";
+                subType: string;
+                data?: unknown;
+                fallback?: string | undefined;
+                id: string;
+                isStreaming?: boolean | undefined;
+            } | {
+                type: "artifact";
+                mimeType: string;
+                artifactType: string;
+                title?: string | undefined;
+                content: string;
+                inline?: boolean | undefined;
+                id: string;
+                isStreaming?: boolean | undefined;
+            } | {
+                type: "pipeline-waiting";
+                id: string;
+                isStreaming?: boolean | undefined;
+            })[] | undefined;
+            status?: import("@aparte/core").AparteStatus | undefined;
+            timestamp: number;
+        }[] | undefined;
+        activeBranchIndex?: number | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    };
+}, __VLS_19: {}, __VLS_27: {}, __VLS_45: {}, __VLS_47: {}, __VLS_49: {};
+type __VLS_Slots = {} & {
+    'empty-state'?: (props: typeof __VLS_7) => any;
+} & {
+    bubble?: (props: typeof __VLS_9) => any;
+} & {
+    'above-composer'?: (props: typeof __VLS_19) => any;
+} & {
+    composer?: (props: typeof __VLS_27) => any;
+} & {
+    'footer-left'?: (props: typeof __VLS_45) => any;
+} & {
+    'footer-center'?: (props: typeof __VLS_47) => any;
+} & {
+    'footer-right'?: (props: typeof __VLS_49) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<Props, {
+    appendMessage: (m: AparteMessage) => void | undefined;
+    updateMessage: (id: string, u: Partial<AparteMessage>) => void | undefined;
+    updateLastMessage: (c: string, o?: {
+        append?: boolean;
+    }) => void | undefined;
+    addSegment: (s: AparteSegment) => void | undefined;
+    updateSegment: (id: string, u: Partial<AparteSegment>) => void | undefined;
+    removeSegment: (id: string) => void | undefined;
+    appendToSegment: (id: string, c: string) => void | undefined;
+    getMessages: () => AparteMessage[];
+    clearMessages: () => void | undefined;
+    addBranch: (id: string) => number;
+    addSiblingOf: (id: string, m: AparteMessage) => string | null;
+    truncateFrom: (id: string) => void | undefined;
+    truncateResponsesAfter: (id: string) => void | undefined;
+    injectTokenStream: (id: string, tokens: AsyncIterable<string>) => Promise<void>;
+    stopTokenStream: () => void | undefined;
+    setConversationId: (id: string | null) => Promise<void>;
+    scrollToBottom: () => void | undefined;
+    focusInput: () => void | undefined;
+    isStreaming: () => boolean;
+    getViewport: () => HTMLElement | null;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    action: (detail: AparteActionEventDetail) => any;
+    messageSent: (event: AparteSendEventDetail) => any;
+    messagesChange: (messages: AparteMessage[]) => any;
+    "update:messages": (messages: AparteMessage[]) => any;
+    messageAppended: (message: AparteMessage) => any;
+    typingChange: (isTyping: boolean) => any;
+    conversationCreated: (id: string) => any;
+}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{
+    onAction?: ((detail: AparteActionEventDetail) => any) | undefined;
+    onMessageSent?: ((event: AparteSendEventDetail) => any) | undefined;
+    onMessagesChange?: ((messages: AparteMessage[]) => any) | undefined;
+    "onUpdate:messages"?: ((messages: AparteMessage[]) => any) | undefined;
+    onMessageAppended?: ((message: AparteMessage) => any) | undefined;
+    onTypingChange?: ((isTyping: boolean) => any) | undefined;
+    onConversationCreated?: ((id: string) => any) | undefined;
+}>, {
+    messages: AparteMessage[];
+    disabled: boolean;
+    placeholder: string;
+    isTyping: boolean;
+    typingText: string;
+    submitOnEnter: boolean;
+    layoutTransitionMs: number;
+    centerWhenEmpty: boolean;
+    conversationId: string | null;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+//# sourceMappingURL=AparteChat.vue.d.ts.map

package/dist/components/AparteChat.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AparteChat.vue.d.ts","sourceRoot":"","sources":["../../src/components/AparteChat.vue"],"names":[],"mappings":"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"}

package/dist/components/AparteUi.vue.d.ts

@@ -0,0 +1,22 @@
+type __VLS_Props = {
+    /** The custom element tag name (e.g. 'aparte-model-selector'). */
+    name: string;
+    /** Props to apply. Keys starting with `--` become CSS variables. */
+    props?: Record<string, unknown>;
+    /**
+     * Which custom events to forward through `elementEvent`. Defaults to the
+     * interactive aparté surface (DEFAULT_UI_EVENTS); pass your own list to listen to
+     * other events (e.g. ['aparte-composer-change'] for attachments).
+     */
+    events?: string[];
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {
+    getElement: () => HTMLElement | null;
+    callMethod: (methodName: string, ...args: unknown[]) => unknown;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    elementEvent: (event: CustomEvent<any>) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onElementEvent?: ((event: CustomEvent<any>) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;
+//# sourceMappingURL=AparteUi.vue.d.ts.map

package/dist/components/AparteUi.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AparteUi.vue.d.ts","sourceRoot":"","sources":["../../src/components/AparteUi.vue"],"names":[],"mappings":"AA2EA,KAAK,WAAW,GAAG;IACjB,kEAAkE;IAClE,IAAI,EAAE,MAAM,CAAC;IACb,oEAAoE;IACpE,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;;;6BA+CyB,MAAM,WAAW,OAAO,EAAE;;;;;;AA0CrD,wBAQG"}

package/dist/composables/useAparteChat.d.ts

@@ -0,0 +1,89 @@
+import { type Ref } from 'vue';
+import type { AparteChatImperativeApi } from '@aparte/core';
+import type { AparteMessage, AparteSegment } from '../types.js';
+/**
+ * The imperative surface `<AparteChat>` exposes via `defineExpose` — the
+ * canonical contract shared by all four wrappers (`AparteChatImperativeApi`).
+ */
+export type AparteChatInstance = AparteChatImperativeApi;
+/**
+ * Idiomatic Vue ergonomics for `<AparteChat>`. Owns the `messages` ref and a
+ * component template ref so the consumer skips the manual
+ * `@messages-change` → `messages` round-trip.
+ *
+ * @example
+ * const chat = useAparteChat();
+ * // template:
+ * // <AparteChat :ref="chat.chatRef" :messages="chat.messages.value"
+ * //   @messages-change="chat.onMessagesChange" />
+ */
+export declare function useAparteChat(initial?: AparteMessage[]): {
+    messages: Ref<AparteMessage[], AparteMessage[]>;
+    chatRef: Ref<{
+        appendMessage: (message: AparteMessage) => void;
+        updateMessage: (messageId: string, updates: Partial<AparteMessage>) => void;
+        updateLastMessage: (content: string, options?: {
+            append?: boolean;
+        }) => void;
+        addSegment: (segment: AparteSegment) => void;
+        updateSegment: (segmentId: string, updates: Partial<AparteSegment>) => void;
+        removeSegment: (segmentId: string) => void;
+        appendToSegment: (segmentId: string, content: string) => void;
+        getMessages: () => AparteMessage[];
+        clearMessages: () => void;
+        addBranch: (messageId: string) => number;
+        addSiblingOf: (existingId: string, message: AparteMessage) => string | null;
+        truncateFrom: (messageId: string) => void;
+        truncateResponsesAfter: (userMessageId: string) => void;
+        injectTokenStream: (messageId: string, tokens: AsyncIterable<string>) => Promise<void>;
+        stopTokenStream: () => void;
+        setConversationId: (id: string | null) => Promise<void>;
+        scrollToBottom: () => void;
+        focusInput: () => void;
+        isStreaming: () => boolean;
+        getViewport: () => HTMLElement | null;
+    } | null, AparteChatImperativeApi | {
+        appendMessage: (message: AparteMessage) => void;
+        updateMessage: (messageId: string, updates: Partial<AparteMessage>) => void;
+        updateLastMessage: (content: string, options?: {
+            append?: boolean;
+        }) => void;
+        addSegment: (segment: AparteSegment) => void;
+        updateSegment: (segmentId: string, updates: Partial<AparteSegment>) => void;
+        removeSegment: (segmentId: string) => void;
+        appendToSegment: (segmentId: string, content: string) => void;
+        getMessages: () => AparteMessage[];
+        clearMessages: () => void;
+        addBranch: (messageId: string) => number;
+        addSiblingOf: (existingId: string, message: AparteMessage) => string | null;
+        truncateFrom: (messageId: string) => void;
+        truncateResponsesAfter: (userMessageId: string) => void;
+        injectTokenStream: (messageId: string, tokens: AsyncIterable<string>) => Promise<void>;
+        stopTokenStream: () => void;
+        setConversationId: (id: string | null) => Promise<void>;
+        scrollToBottom: () => void;
+        focusInput: () => void;
+        isStreaming: () => boolean;
+        getViewport: () => HTMLElement | null;
+    } | null>;
+    onMessagesChange: (m: AparteMessage[]) => void;
+    appendMessage: (m: AparteMessage) => void | undefined;
+    updateMessage: (id: string, u: Partial<AparteMessage>) => void | undefined;
+    updateLastMessage: (content: string, o?: {
+        append?: boolean;
+    }) => void | undefined;
+    addSegment: (s: AparteSegment) => void | undefined;
+    updateSegment: (id: string, u: Partial<AparteSegment>) => void | undefined;
+    removeSegment: (id: string) => void | undefined;
+    appendToSegment: (id: string, content: string) => void | undefined;
+    clearMessages: () => void | undefined;
+    addBranch: (id: string) => number;
+    addSiblingOf: (id: string, m: AparteMessage) => string | null;
+    truncateFrom: (id: string) => void | undefined;
+    truncateResponsesAfter: (id: string) => void | undefined;
+    injectTokenStream: (id: string, tokens: AsyncIterable<string>) => Promise<void>;
+    stopTokenStream: () => void | undefined;
+    setConversationId: (id: string | null) => Promise<void>;
+    isStreaming: () => boolean;
+};
+//# sourceMappingURL=useAparteChat.d.ts.map

package/dist/composables/useAparteChat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAparteChat.d.ts","sourceRoot":"","sources":["../../src/composables/useAparteChat.ts"],"names":[],"mappings":"AAAA,OAAO,EAAO,KAAK,GAAG,EAAE,MAAM,KAAK,CAAC;AACpC,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AAC5D,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAEhE;;;GAGG;AACH,MAAM,MAAM,kBAAkB,GAAG,uBAAuB,CAAC;AAEzD;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,OAAO,GAAE,aAAa,EAAO;;;;;oDAG/C,CAAA;kBAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;oDAAX,CAAA;kBAAU,CAAC;;;;;;;;;;;;;;;;;;;;0BACU,aAAa,EAAE;uBAMrB,aAAa;wBACZ,MAAM,KAAK,OAAO,CAAC,aAAa,CAAC;iCACxB,MAAM,MAAM;QAAE,MAAM,CAAC,EAAE,OAAO,CAAA;KAAE;oBAC7C,aAAa;wBACT,MAAM,KAAK,OAAO,CAAC,aAAa,CAAC;wBACjC,MAAM;0BACJ,MAAM,WAAW,MAAM;;oBAE7B,MAAM;uBACH,MAAM,KAAK,aAAa;uBACxB,MAAM;iCACI,MAAM;4BACX,MAAM,UAAU,aAAa,CAAC,MAAM,CAAC;;4BAGrC,MAAM,GAAG,IAAI;;EAG5C"}

package/dist/composables/useAparteClient.d.ts

@@ -0,0 +1,11 @@
+import { AparteClient, type AparteClientOptions } from '@aparte/core';
+/**
+ * Mounts an `AparteClient` that bridges `aparte-send` events to the configured AI
+ * providers. Starts on mount, stops on unmount. Vue equivalent of Angular's
+ * `AparteAiService`.
+ */
+export declare function useAparteClient(options?: AparteClientOptions): {
+    client: AparteClient;
+    abort: () => void;
+};
+//# sourceMappingURL=useAparteClient.d.ts.map

package/dist/composables/useAparteClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAparteClient.d.ts","sourceRoot":"","sources":["../../src/composables/useAparteClient.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,KAAK,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAEtE;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,OAAO,CAAC,EAAE,mBAAmB;;;EAK5D"}

package/dist/composables/useConversationManager.d.ts

@@ -0,0 +1,24 @@
+import { type Ref } from 'vue';
+import { type AparteConversation, type AparteStorageAdapter } from '@aparte/core';
+import type { AparteMessage } from '../types.js';
+/**
+ * Vue-reactive wrapper around the core `ConversationManager`. The active
+ * conversation is owned by the chat component's controller; switch by binding
+ * `conversationId` on `<AparteChat>`. Vue equivalent of Angular's
+ * `ConversationManagerService`.
+ */
+export declare function useConversationManager(): {
+    conversations: Ref<AparteConversation[], AparteConversation[]>;
+    activeConversations: import("vue").ComputedRef<AparteConversation[]>;
+    archivedConversations: import("vue").ComputedRef<AparteConversation[]>;
+    activeId: Ref<string | null, string | null>;
+    activeConversation: import("vue").ComputedRef<AparteConversation | null>;
+    init: (adapter: AparteStorageAdapter) => Promise<void>;
+    createNew: (title?: string) => Promise<AparteConversation>;
+    addMessage: (convId: string, message: AparteMessage) => Promise<void>;
+    updateMessages: (convId: string, messages: AparteMessage[]) => Promise<void>;
+    delete: (id: string) => Promise<void>;
+    archive: (id: string) => Promise<void>;
+    unarchive: (id: string) => Promise<void>;
+};
+//# sourceMappingURL=useConversationManager.d.ts.map

package/dist/composables/useConversationManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useConversationManager.d.ts","sourceRoot":"","sources":["../../src/composables/useConversationManager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkC,KAAK,GAAG,EAAE,MAAM,KAAK,CAAC;AAC/D,OAAO,EAGH,KAAK,kBAAkB,EACvB,KAAK,oBAAoB,EAC5B,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAEjD;;;;;GAKG;AACH,wBAAgB,sBAAsB;;;;;;oBAwBL,oBAAoB,KAAG,OAAO,CAAC,IAAI,CAAC;wBAmBzC,MAAM;yBACL,MAAM,WAAW,aAAa;6BAC1B,MAAM,YAAY,aAAa,EAAE;iBAC7C,MAAM;kBACL,MAAM;oBACJ,MAAM;EAE7B"}

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * aparté Vue wrapper
+ * Vue 3 integration with Composition API and segment support
+ */
+import AparteChat from './components/AparteChat.vue';
+export { AparteChat };
+export { useAparteChat } from './composables/useAparteChat.js';
+export type { AparteChatInstance } from './composables/useAparteChat.js';
+export { useAparteClient } from './composables/useAparteClient.js';
+export { useConversationManager } from './composables/useConversationManager.js';
+import AparteUi from './components/AparteUi.vue';
+export { AparteUi };
+export type { AparteUiProps, AparteUiHandle } from './types.js';
+export type { AparteMessage, AparteSendEventDetail, AparteActionEventDetail, AparteSegment, AparteTextSegment, AparteCodeSegment, AparteThinkingSegment, AparteTerminalSegment } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,UAAU,MAAM,6BAA6B,CAAC;AACrD,OAAO,EAAE,UAAU,EAAE,CAAC;AAGtB,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAC/D,YAAY,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAGzE,OAAO,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AACnE,OAAO,EAAE,sBAAsB,EAAE,MAAM,yCAAyC,CAAC;AACjF,OAAO,QAAQ,MAAM,2BAA2B,CAAC;AACjD,OAAO,EAAE,QAAQ,EAAE,CAAC;AACpB,YAAY,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEhE,YAAY,EACR,aAAa,EACb,qBAAqB,EACrB,uBAAuB,EACvB,aAAa,EACb,iBAAiB,EACjB,iBAAiB,EACjB,qBAAqB,EACrB,qBAAqB,EACxB,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,359 @@
+import { defineComponent, useId, ref, onMounted, toRaw, onBeforeUnmount, watch, nextTick, openBlock, createElementBlock, normalizeClass, createElementVNode, renderSlot, createCommentVNode, Fragment, renderList, computed } from "vue";
+import { AparteChatHost, AparteClient, ConversationManager, AparteConfig, DEFAULT_UI_EVENTS, applyElementProps } from "@aparte/core";
+const _hoisted_1 = ["data-aparte-empty"];
+const _hoisted_2 = ["message-id", "data-role", "timestamp", "content", "streaming"];
+const _hoisted_3 = ["visible", "text"];
+const _hoisted_4 = ["^placeholder", "^disabled", "submit-on-enter"];
+const _hoisted_5 = { class: "aparte-composer-shell" };
+const _hoisted_6 = {
+  key: 0,
+  class: "aparte-composer-footer"
+};
+const _sfc_main$1 = /* @__PURE__ */ defineComponent({
+  __name: "AparteChat",
+  props: {
+    messages: { default: () => [] },
+    placeholder: { default: "Type a message..." },
+    disabled: { type: Boolean, default: false },
+    isTyping: { type: Boolean, default: false },
+    typingText: { default: "Assistant is thinking..." },
+    submitOnEnter: { type: Boolean, default: true },
+    layoutTransitionMs: { default: 0 },
+    centerWhenEmpty: { type: Boolean, default: false },
+    conversationId: { default: null },
+    config: {}
+  },
+  emits: ["messageSent", "action", "messagesChange", "update:messages", "messageAppended", "typingChange", "conversationCreated"],
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const hostId = `aparte-chat-${useId()}`;
+    const rootRef = ref();
+    const viewportRef = ref();
+    const composerRef = ref();
+    const internalMessages = ref([...props.messages]);
+    const typingActive = ref(props.isTyping);
+    let host = null;
+    let teardown = null;
+    function onSend(e) {
+      viewportRef.value?.requestSmoothScroll?.();
+      emit("messageSent", e.detail);
+    }
+    function onAction(e) {
+      emit("action", e.detail);
+    }
+    onMounted(() => {
+      const binding = {
+        hostId,
+        host: rootRef.value,
+        viewport: viewportRef.value ?? null,
+        getMessages: () => internalMessages.value,
+        setMessages: (m) => {
+          internalMessages.value = m;
+        },
+        onMessagesChange: (m) => {
+          emit("messagesChange", m);
+          emit("update:messages", m);
+        },
+        onMessageAppended: (m) => emit("messageAppended", m),
+        onTypingChange: (t) => {
+          typingActive.value = t;
+          emit("typingChange", t);
+        },
+        onStreamingChange: () => {
+        },
+        afterRender: (cb) => {
+          void nextTick(cb);
+        },
+        resetComposer: () => composerRef.value?.reset?.()
+      };
+      host = new AparteChatHost(binding, {
+        layoutTransitionMs: props.layoutTransitionMs,
+        conversationId: props.conversationId ?? null,
+        onConversationCreated: (id) => emit("conversationCreated", id),
+        // Unwrap Vue's reactive proxy: the config is a plain class with internal
+        // Map registries the host/components must operate on directly, not through a
+        // deep reactive proxy (which would wrap those Maps and break lookups).
+        config: props.config ? toRaw(props.config) : void 0
+      });
+      teardown = host.bind();
+      host.syncBubbles();
+      composerRef.value?.addEventListener("aparte-send", onSend);
+      rootRef.value?.addEventListener("aparte-action", onAction);
+    });
+    onBeforeUnmount(() => {
+      composerRef.value?.removeEventListener("aparte-send", onSend);
+      rootRef.value?.removeEventListener("aparte-action", onAction);
+      teardown?.();
+      teardown = null;
+      host = null;
+    });
+    watch(() => props.messages, (m) => {
+      if (m === internalMessages.value) return;
+      internalMessages.value = [...m];
+      if (m.length === 0) host?.clearRenderCache();
+    });
+    watch(internalMessages, () => {
+      void nextTick(() => host?.syncBubbles());
+    });
+    watch(() => props.isTyping, (t) => {
+      typingActive.value = t;
+    });
+    watch(() => props.conversationId, (id) => {
+      void host?.setConversationId(id ?? null);
+    });
+    const appendMessage = (m) => host?.appendMessage(m);
+    const updateMessage = (id, u) => host?.updateMessage(id, u);
+    const updateLastMessage = (c, o) => host?.updateLastMessage(c, o);
+    const addSegment = (s) => host?.addSegment(s);
+    const updateSegment = (id, u) => host?.updateSegment(id, u);
+    const removeSegment = (id) => host?.removeSegment(id);
+    const appendToSegment = (id, c) => host?.appendToSegment(id, c);
+    const getMessages = () => host?.getMessages() ?? internalMessages.value;
+    const clearMessages = () => host?.clearMessages();
+    const addBranch = (id) => host?.addBranch(id) ?? 0;
+    const addSiblingOf = (id, m) => host?.addSiblingOf(id, m) ?? null;
+    const truncateFrom = (id) => host?.truncateFrom(id);
+    const truncateResponsesAfter = (id) => host?.truncateResponsesAfter(id);
+    const injectTokenStream = (id, tokens) => host?.streamTokens(id, tokens) ?? Promise.resolve();
+    const stopTokenStream = () => host?.stopTokenStream();
+    const setConversationId = (id) => host?.setConversationId(id) ?? Promise.resolve();
+    const scrollToBottom = () => viewportRef.value?.scrollToBottom?.();
+    const focusInput = () => composerRef.value?.focus?.();
+    const isStreaming = () => host?.isStreaming ?? false;
+    const getViewport = () => viewportRef.value ?? null;
+    __expose({
+      appendMessage,
+      updateMessage,
+      updateLastMessage,
+      addSegment,
+      updateSegment,
+      removeSegment,
+      appendToSegment,
+      getMessages,
+      clearMessages,
+      addBranch,
+      addSiblingOf,
+      truncateFrom,
+      truncateResponsesAfter,
+      injectTokenStream,
+      stopTokenStream,
+      setConversationId,
+      scrollToBottom,
+      focusInput,
+      isStreaming,
+      getViewport
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(["aparte-chat-container", { "aparte-chat-container--auto-center": __props.centerWhenEmpty }]),
+        "data-aparte-chat": "",
+        "data-aparte-empty": __props.centerWhenEmpty && internalMessages.value.length === 0 ? "" : null,
+        id: hostId,
+        ref_key: "rootRef",
+        ref: rootRef
+      }, [
+        createElementVNode("aparte-chat-viewport", {
+          ref_key: "viewportRef",
+          ref: viewportRef,
+          "framework-managed": ""
+        }, [
+          internalMessages.value.length === 0 ? renderSlot(_ctx.$slots, "empty-state", { key: 0 }) : createCommentVNode("", true),
+          (openBlock(true), createElementBlock(Fragment, null, renderList(internalMessages.value, (m) => {
+            return renderSlot(_ctx.$slots, "bubble", {
+              key: m.id,
+              message: m
+            }, () => [
+              createElementVNode("aparte-chat-bubble", {
+                "message-id": m.id,
+                "data-role": m.role,
+                timestamp: m.timestamp,
+                content: m.content,
+                streaming: m.status === "streaming" || m.status === "pending" ? "" : null
+              }, null, 8, _hoisted_2)
+            ]);
+          }), 128)),
+          createElementVNode("aparte-chat-status", {
+            visible: typingActive.value ? "" : null,
+            text: __props.typingText
+          }, null, 8, _hoisted_3)
+        ], 512),
+        renderSlot(_ctx.$slots, "above-composer"),
+        createElementVNode("aparte-composer", {
+          ref_key: "composerRef",
+          ref: composerRef,
+          target: hostId,
+          "^placeholder": __props.placeholder,
+          "^disabled": __props.disabled ? "" : null,
+          "submit-on-enter": __props.submitOnEnter ? null : "false"
+        }, [
+          renderSlot(_ctx.$slots, "composer", {}, () => [
+            createElementVNode("div", _hoisted_5, [
+              _cache[0] || (_cache[0] = createElementVNode("aparte-composer-attachments", null, null, -1)),
+              _cache[1] || (_cache[1] = createElementVNode("div", { class: "aparte-composer-row" }, [
+                createElementVNode("aparte-composer-add-attachment"),
+                createElementVNode("aparte-composer-input"),
+                createElementVNode("aparte-composer-send")
+              ], -1)),
+              _ctx.$slots["footer-left"] || _ctx.$slots["footer-center"] || _ctx.$slots["footer-right"] ? (openBlock(), createElementBlock("div", _hoisted_6, [
+                renderSlot(_ctx.$slots, "footer-left"),
+                renderSlot(_ctx.$slots, "footer-center"),
+                renderSlot(_ctx.$slots, "footer-right")
+              ])) : createCommentVNode("", true)
+            ])
+          ])
+        ], 8, _hoisted_4)
+      ], 10, _hoisted_1);
+    };
+  }
+});
+function useAparteChat(initial = []) {
+  const messages = ref([...initial]);
+  const chatRef = ref(null);
+  const c = () => chatRef.value;
+  const onMessagesChange = (m) => {
+    messages.value = m;
+  };
+  return {
+    messages,
+    chatRef,
+    onMessagesChange,
+    appendMessage: (m) => c()?.appendMessage(m),
+    updateMessage: (id, u) => c()?.updateMessage(id, u),
+    updateLastMessage: (content, o) => c()?.updateLastMessage(content, o),
+    addSegment: (s) => c()?.addSegment(s),
+    updateSegment: (id, u) => c()?.updateSegment(id, u),
+    removeSegment: (id) => c()?.removeSegment(id),
+    appendToSegment: (id, content) => c()?.appendToSegment(id, content),
+    clearMessages: () => c()?.clearMessages(),
+    addBranch: (id) => c()?.addBranch(id) ?? 0,
+    addSiblingOf: (id, m) => c()?.addSiblingOf(id, m) ?? null,
+    truncateFrom: (id) => c()?.truncateFrom(id),
+    truncateResponsesAfter: (id) => c()?.truncateResponsesAfter(id),
+    injectTokenStream: (id, tokens) => c()?.injectTokenStream(id, tokens) ?? Promise.resolve(),
+    stopTokenStream: () => c()?.stopTokenStream(),
+    setConversationId: (id) => c()?.setConversationId(id) ?? Promise.resolve(),
+    isStreaming: () => c()?.isStreaming() ?? false
+  };
+}
+function useAparteClient(options) {
+  const client = new AparteClient(options ?? {});
+  onMounted(() => client.start());
+  onBeforeUnmount(() => client.stop());
+  return { client, abort: () => client.abort() };
+}
+function useConversationManager() {
+  let manager = null;
+  let unsub = null;
+  const conversations = ref([]);
+  const activeId = ref(null);
+  const activeConversations = computed(
+    () => conversations.value.filter((c) => !c.archivedAt).sort((a, b) => b.updatedAt - a.updatedAt)
+  );
+  const archivedConversations = computed(
+    () => conversations.value.filter((c) => !!c.archivedAt).sort((a, b) => b.updatedAt - a.updatedAt)
+  );
+  const activeConversation = computed(
+    () => activeId.value ? conversations.value.find((c) => c.id === activeId.value) ?? null : null
+  );
+  onBeforeUnmount(() => unsub?.());
+  const assert = () => {
+    if (!manager) throw new Error("[useConversationManager] Not initialised. Call init(adapter) first.");
+    return manager;
+  };
+  const init = async (adapter) => {
+    const m = new ConversationManager(adapter);
+    manager = m;
+    unsub = m.subscribe((convs) => {
+      conversations.value = [...convs];
+      activeId.value = m.activeId;
+    });
+    await m.init();
+    activeId.value = m.activeId;
+    AparteConfig.setConversationManager(m);
+  };
+  return {
+    conversations,
+    activeConversations,
+    archivedConversations,
+    activeId,
+    activeConversation,
+    init,
+    createNew: (title) => assert().createNew(title),
+    addMessage: (convId, message) => assert().addMessage(convId, message),
+    updateMessages: (convId, messages) => assert().updateMessages(convId, messages),
+    delete: (id) => assert().delete(id),
+    archive: (id) => assert().archive(id),
+    unarchive: (id) => assert().unarchive(id)
+  };
+}
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "AparteUi",
+  props: {
+    name: {},
+    props: {},
+    events: {}
+  },
+  emits: ["elementEvent"],
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const p = __props;
+    const emit = __emit;
+    const evtsKey = computed(() => (p.events ?? DEFAULT_UI_EVENTS).join("|"));
+    const hostRef = ref();
+    let el = null;
+    let cleanups = [];
+    function applyProps() {
+      if (el) applyElementProps(el, p.props ?? {}, toRaw);
+    }
+    function create() {
+      if (!hostRef.value) return;
+      el = document.createElement(p.name);
+      applyProps();
+      for (const ev of evtsKey.value.split("|").filter(Boolean)) {
+        const listener = (e) => emit("elementEvent", e);
+        el.addEventListener(ev, listener);
+        cleanups.push(() => el?.removeEventListener(ev, listener));
+      }
+      hostRef.value.appendChild(el);
+    }
+    function destroy() {
+      for (const c of cleanups) c();
+      cleanups = [];
+      el?.remove();
+      el = null;
+    }
+    onMounted(create);
+    onBeforeUnmount(destroy);
+    watch(() => p.name, () => {
+      destroy();
+      create();
+    });
+    watch(evtsKey, () => {
+      destroy();
+      create();
+    });
+    watch(() => p.props, applyProps, { deep: true });
+    __expose({
+      getElement: () => el,
+      callMethod: (methodName, ...args) => {
+        const fn = el?.[methodName];
+        return typeof fn === "function" ? fn.apply(el, args) : void 0;
+      }
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("span", {
+        ref_key: "hostRef",
+        ref: hostRef,
+        style: { "display": "contents" }
+      }, null, 512);
+    };
+  }
+});
+export {
+  _sfc_main$1 as AparteChat,
+  _sfc_main as AparteUi,
+  useAparteChat,
+  useAparteClient,
+  useConversationManager
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../src/components/AparteChat.vue","../src/composables/useAparteChat.ts","../src/composables/useAparteClient.ts","../src/composables/useConversationManager.ts","../src/components/AparteUi.vue"],"sourcesContent":["<script setup lang=\"ts\">\nimport { ref, watch, onMounted, onBeforeUnmount, nextTick, useId, toRaw } from 'vue';\nimport { AparteChatHost, type AparteChatHostBinding, type AparteConfigClass, type AparteChatImperativeApi } from '@aparte/core';\nimport type { AparteMessage, AparteSegment, AparteSendEventDetail, AparteActionEventDetail } from '../types.js';\n\ninterface Props {\n  /** Optional: omit for an uncontrolled chat (defaults to []); use `v-model:messages` to control. */\n  messages?: AparteMessage[];\n  placeholder?: string;\n  disabled?: boolean;\n  isTyping?: boolean;\n  typingText?: string;\n  /** When false, Shift+Enter submits and a bare Enter inserts a newline. */\n  submitOnEnter?: boolean;\n  /** Freeze viewport spacer recalculation for this many ms after a conv swap. */\n  layoutTransitionMs?: number;\n  /**\n   * Opt in to the \"centered composer when empty\" layout: the composer sits\n   * vertically centered with the `empty-state` slot above it while the list is\n   * empty, then slides to the bottom on the first message (~0.3s). Off by\n   * default — additive (adds the `--auto-center` modifier + a `data-aparte-empty`\n   * attribute the shipped `aparte.css` recipe keys off).\n   */\n  centerWhenEmpty?: boolean;\n  /** Active conversation id (loads/persists via the registered ConversationManager). */\n  conversationId?: string | null;\n  /**\n   * Instance {@link AparteConfigClass} for this chat. When set, aparté components\n   * inside resolve THIS config instead of the global `AparteConfig` singleton, so\n   * several independently-configured chats can coexist on one page. Omit for the\n   * global config. Read once when the host mounts.\n   */\n  config?: AparteConfigClass;\n}\n\nconst props = withDefaults(defineProps<Props>(), {\n  messages: () => [],\n  placeholder: 'Type a message...',\n  disabled: false,\n  isTyping: false,\n  typingText: 'Assistant is thinking...',\n  submitOnEnter: true,\n  layoutTransitionMs: 0,\n  centerWhenEmpty: false,\n  conversationId: null,\n});\n\nconst emit = defineEmits<{\n  /**\n   * User submitted a message from the composer. The message is **appended to\n   * the thread automatically** (optimistic UI) before this fires — do NOT add\n   * it again in the handler (uncontrolled → duplicates; controlled → mirror it\n   * into your own `messages`). For side-effects: scroll, analytics, send.\n   */\n  messageSent: [event: AparteSendEventDetail];\n  /** A custom bubble action (registerBubbleAction) was clicked — typed aparte-action. */\n  action: [detail: AparteActionEventDetail];\n  /** Active path changed (branch nav/edit/retry/streaming) — bind back to `messages`. */\n  messagesChange: [messages: AparteMessage[]];\n  /** Same payload as `messagesChange`, enabling `v-model:messages`. */\n  'update:messages': [messages: AparteMessage[]];\n  messageAppended: [message: AparteMessage];\n  /** The typing/\"thinking\" indicator toggled (the host flips it off on the first streamed token). */\n  typingChange: [isTyping: boolean];\n  conversationCreated: [id: string];\n}>();\n\n// useId() (Vue 3.5+) is SSR-stable — server and client agree, no hydration mismatch.\nconst hostId = `aparte-chat-${useId()}`;\nconst rootRef = ref<HTMLElement>();\nconst viewportRef = ref<HTMLElement>();\nconst composerRef = ref<HTMLElement>();\nconst internalMessages = ref<AparteMessage[]>([...props.messages]);\nconst typingActive = ref(props.isTyping);\n\nlet host: AparteChatHost | null = null;\nlet teardown: (() => void) | null = null;\n\nfunction onSend(e: Event) {\n  (viewportRef.value as unknown as { requestSmoothScroll?: () => void })?.requestSmoothScroll?.();\n  emit('messageSent', (e as CustomEvent<AparteSendEventDetail>).detail);\n}\n\n// Custom bubble actions bubble to the root as `aparte-action` — surface them typed.\nfunction onAction(e: Event) {\n  emit('action', (e as CustomEvent<AparteActionEventDetail>).detail);\n}\n\nonMounted(() => {\n  const binding: AparteChatHostBinding = {\n    hostId,\n    host: rootRef.value as HTMLElement,\n    viewport: viewportRef.value ?? null,\n    getMessages: () => internalMessages.value,\n    setMessages: (m) => { internalMessages.value = m as AparteMessage[]; },\n    onMessagesChange: (m) => { emit('messagesChange', m as AparteMessage[]); emit('update:messages', m as AparteMessage[]); },\n    onMessageAppended: (m) => emit('messageAppended', m as AparteMessage),\n    onTypingChange: (t) => { typingActive.value = t; emit('typingChange', t); },\n    onStreamingChange: () => { /* exposed via isStreaming() */ },\n    afterRender: (cb) => { void nextTick(cb); },\n    resetComposer: () => (composerRef.value as unknown as { reset?: () => void })?.reset?.(),\n  };\n  host = new AparteChatHost(binding, {\n    layoutTransitionMs: props.layoutTransitionMs,\n    conversationId: props.conversationId ?? null,\n    onConversationCreated: (id) => emit('conversationCreated', id),\n    // Unwrap Vue's reactive proxy: the config is a plain class with internal\n    // Map registries the host/components must operate on directly, not through a\n    // deep reactive proxy (which would wrap those Maps and break lookups).\n    config: props.config ? toRaw(props.config) : undefined,\n  });\n  teardown = host.bind();\n  host.syncBubbles();\n  composerRef.value?.addEventListener('aparte-send', onSend);\n  rootRef.value?.addEventListener('aparte-action', onAction);\n});\n\nonBeforeUnmount(() => {\n  composerRef.value?.removeEventListener('aparte-send', onSend);\n  rootRef.value?.removeEventListener('aparte-action', onAction);\n  teardown?.();\n  teardown = null;\n  host = null;\n});\n\n// Parent push → internal list (guarded against the host's own emit round-trip).\nwatch(() => props.messages, (m) => {\n  if (m === internalMessages.value) return;\n  internalMessages.value = [...m];\n  if (m.length === 0) host?.clearRenderCache();\n});\n\n// Reconcile bubbles after the rendered list changes (host queries the DOM).\nwatch(internalMessages, () => { void nextTick(() => host?.syncBubbles()); });\n\nwatch(() => props.isTyping, (t) => { typingActive.value = t; });\nwatch(() => props.conversationId, (id) => { void host?.setConversationId(id ?? null); });\n\n// ── Imperative API (forwards to the host) ──\nconst appendMessage = (m: AparteMessage) => host?.appendMessage(m);\nconst updateMessage = (id: string, u: Partial<AparteMessage>) => host?.updateMessage(id, u);\nconst updateLastMessage = (c: string, o?: { append?: boolean }) => host?.updateLastMessage(c, o);\nconst addSegment = (s: AparteSegment) => host?.addSegment(s);\nconst updateSegment = (id: string, u: Partial<AparteSegment>) => host?.updateSegment(id, u);\nconst removeSegment = (id: string) => host?.removeSegment(id);\nconst appendToSegment = (id: string, c: string) => host?.appendToSegment(id, c);\nconst getMessages = () => host?.getMessages() ?? internalMessages.value;\nconst clearMessages = () => host?.clearMessages();\nconst addBranch = (id: string) => host?.addBranch(id) ?? 0;\nconst addSiblingOf = (id: string, m: AparteMessage) => host?.addSiblingOf(id, m) ?? null;\nconst truncateFrom = (id: string) => host?.truncateFrom(id);\nconst truncateResponsesAfter = (id: string) => host?.truncateResponsesAfter(id);\nconst injectTokenStream = (id: string, tokens: AsyncIterable<string>) =>\n  host?.streamTokens(id, tokens) ?? Promise.resolve();\nconst stopTokenStream = () => host?.stopTokenStream();\nconst setConversationId = (id: string | null) => host?.setConversationId(id) ?? Promise.resolve();\nconst scrollToBottom = () => (viewportRef.value as unknown as { scrollToBottom?: () => void })?.scrollToBottom?.();\nconst focusInput = () => (composerRef.value as unknown as { focus?: () => void })?.focus?.();\nconst isStreaming = () => host?.isStreaming ?? false;\n\n// `getViewport()` (not a raw `viewport` ref): the same accessor on all four\n// wrappers — Svelte 4 can only expose functions, so the shared name is one.\nconst getViewport = () => viewportRef.value ?? null;\n\n// `satisfies` makes a dropped or mistyped method a compile error — the canonical\n// AparteChatImperativeApi is enforced here, not just aliased for consumers.\ndefineExpose({\n  appendMessage, updateMessage, updateLastMessage, addSegment, updateSegment, removeSegment,\n  appendToSegment, getMessages, clearMessages, addBranch, addSiblingOf, truncateFrom,\n  truncateResponsesAfter, injectTokenStream, stopTokenStream, setConversationId,\n  scrollToBottom, focusInput, isStreaming, getViewport,\n} satisfies AparteChatImperativeApi);\n</script>\n\n<template>\n  <div\n    :class=\"['aparte-chat-container', { 'aparte-chat-container--auto-center': centerWhenEmpty }]\"\n    data-aparte-chat\n    :data-aparte-empty=\"centerWhenEmpty && internalMessages.length === 0 ? '' : null\"\n    :id=\"hostId\"\n    ref=\"rootRef\"\n  >\n    <aparte-chat-viewport ref=\"viewportRef\" framework-managed=\"\">\n      <!-- Welcome / placeholder shown inside the viewport while there are no\n           messages (a real empty-state region). -->\n      <slot v-if=\"internalMessages.length === 0\" name=\"empty-state\" />\n      <!-- `bubble` scoped slot renders your OWN element per message in place of\n           <aparte-chat-bubble>; driven by the reactive list so it streams live. -->\n      <template v-for=\"m in internalMessages\" :key=\"m.id\">\n        <slot name=\"bubble\" :message=\"m\">\n          <aparte-chat-bubble\n            :message-id=\"m.id\"\n            :data-role=\"m.role\"\n            :timestamp=\"m.timestamp\"\n            :content=\"m.content\"\n            :streaming=\"(m.status === 'streaming' || m.status === 'pending') ? '' : null\"\n          />\n        </slot>\n      </template>\n      <aparte-chat-status :visible=\"typingActive ? '' : null\" :text=\"typingText\" />\n    </aparte-chat-viewport>\n\n    <!-- Content above the composer (banner, disclaimer, context chip). -->\n    <slot name=\"above-composer\" />\n\n    <!-- `.attr` forces attribute-setting: core's <aparte-composer> exposes\n         `placeholder`/`disabled` as getter-only accessors, so Vue's default\n         property-set (it prefers props on custom elements) would throw and the\n         value would silently never apply. -->\n    <aparte-composer\n      ref=\"composerRef\"\n      :target=\"hostId\"\n      :placeholder.attr=\"placeholder\"\n      :disabled.attr=\"disabled ? '' : null\"\n      :submit-on-enter=\"submitOnEnter ? null : 'false'\"\n    >\n      <!-- Custom composer via the `composer` slot; falls back to the default\n           shell (add-attachment · input · send). Compose the headless\n           aparte-composer-* primitives freely for a skin-specific layout. -->\n      <slot name=\"composer\">\n        <div class=\"aparte-composer-shell\">\n          <aparte-composer-attachments></aparte-composer-attachments>\n          <div class=\"aparte-composer-row\">\n            <aparte-composer-add-attachment></aparte-composer-add-attachment>\n            <aparte-composer-input></aparte-composer-input>\n            <aparte-composer-send></aparte-composer-send>\n          </div>\n          <!-- Footer slots (model selector, token counter…). The row is\n               removed from view by .aparte-composer-footer:empty when unused. -->\n          <div\n            v-if=\"$slots['footer-left'] || $slots['footer-center'] || $slots['footer-right']\"\n            class=\"aparte-composer-footer\"\n          >\n            <slot name=\"footer-left\" />\n            <slot name=\"footer-center\" />\n            <slot name=\"footer-right\" />\n          </div>\n        </div>\n      </slot>\n    </aparte-composer>\n  </div>\n</template>\n","import { ref, type Ref } from 'vue';\nimport type { AparteChatImperativeApi } from '@aparte/core';\nimport type { AparteMessage, AparteSegment } from '../types.js';\n\n/**\n * The imperative surface `<AparteChat>` exposes via `defineExpose` — the\n * canonical contract shared by all four wrappers (`AparteChatImperativeApi`).\n */\nexport type AparteChatInstance = AparteChatImperativeApi;\n\n/**\n * Idiomatic Vue ergonomics for `<AparteChat>`. Owns the `messages` ref and a\n * component template ref so the consumer skips the manual\n * `@messages-change` → `messages` round-trip.\n *\n * @example\n * const chat = useAparteChat();\n * // template:\n * // <AparteChat :ref=\"chat.chatRef\" :messages=\"chat.messages.value\"\n * //   @messages-change=\"chat.onMessagesChange\" />\n */\nexport function useAparteChat(initial: AparteMessage[] = []) {\n    const messages = ref<AparteMessage[]>([...initial]) as Ref<AparteMessage[]>;\n    const chatRef = ref<AparteChatInstance | null>(null);\n    const c = () => chatRef.value;\n    const onMessagesChange = (m: AparteMessage[]) => { messages.value = m; };\n\n    return {\n        messages,\n        chatRef,\n        onMessagesChange,\n        appendMessage: (m: AparteMessage) => c()?.appendMessage(m),\n        updateMessage: (id: string, u: Partial<AparteMessage>) => c()?.updateMessage(id, u),\n        updateLastMessage: (content: string, o?: { append?: boolean }) => c()?.updateLastMessage(content, o),\n        addSegment: (s: AparteSegment) => c()?.addSegment(s),\n        updateSegment: (id: string, u: Partial<AparteSegment>) => c()?.updateSegment(id, u),\n        removeSegment: (id: string) => c()?.removeSegment(id),\n        appendToSegment: (id: string, content: string) => c()?.appendToSegment(id, content),\n        clearMessages: () => c()?.clearMessages(),\n        addBranch: (id: string) => c()?.addBranch(id) ?? 0,\n        addSiblingOf: (id: string, m: AparteMessage) => c()?.addSiblingOf(id, m) ?? null,\n        truncateFrom: (id: string) => c()?.truncateFrom(id),\n        truncateResponsesAfter: (id: string) => c()?.truncateResponsesAfter(id),\n        injectTokenStream: (id: string, tokens: AsyncIterable<string>) =>\n            c()?.injectTokenStream(id, tokens) ?? Promise.resolve(),\n        stopTokenStream: () => c()?.stopTokenStream(),\n        setConversationId: (id: string | null) => c()?.setConversationId(id) ?? Promise.resolve(),\n        isStreaming: () => c()?.isStreaming() ?? false,\n    };\n}\n","import { onMounted, onBeforeUnmount } from 'vue';\nimport { AparteClient, type AparteClientOptions } from '@aparte/core';\n\n/**\n * Mounts an `AparteClient` that bridges `aparte-send` events to the configured AI\n * providers. Starts on mount, stops on unmount. Vue equivalent of Angular's\n * `AparteAiService`.\n */\nexport function useAparteClient(options?: AparteClientOptions) {\n    const client = new AparteClient(options ?? {});\n    onMounted(() => client.start());\n    onBeforeUnmount(() => client.stop());\n    return { client, abort: () => client.abort() };\n}\n","import { ref, computed, onBeforeUnmount, type Ref } from 'vue';\nimport {\n    AparteConfig,\n    ConversationManager,\n    type AparteConversation,\n    type AparteStorageAdapter,\n} from '@aparte/core';\nimport type { AparteMessage } from '../types.js';\n\n/**\n * Vue-reactive wrapper around the core `ConversationManager`. The active\n * conversation is owned by the chat component's controller; switch by binding\n * `conversationId` on `<AparteChat>`. Vue equivalent of Angular's\n * `ConversationManagerService`.\n */\nexport function useConversationManager() {\n    let manager: ConversationManager | null = null;\n    let unsub: (() => void) | null = null;\n\n    const conversations = ref<AparteConversation[]>([]) as Ref<AparteConversation[]>;\n    const activeId = ref<string | null>(null);\n\n    const activeConversations = computed(() =>\n        conversations.value.filter((c) => !c.archivedAt).sort((a, b) => b.updatedAt - a.updatedAt),\n    );\n    const archivedConversations = computed(() =>\n        conversations.value.filter((c) => !!c.archivedAt).sort((a, b) => b.updatedAt - a.updatedAt),\n    );\n    const activeConversation = computed(() =>\n        activeId.value ? conversations.value.find((c) => c.id === activeId.value) ?? null : null,\n    );\n\n    onBeforeUnmount(() => unsub?.());\n\n    const assert = (): ConversationManager => {\n        if (!manager) throw new Error('[useConversationManager] Not initialised. Call init(adapter) first.');\n        return manager;\n    };\n\n    const init = async (adapter: AparteStorageAdapter): Promise<void> => {\n        const m = new ConversationManager(adapter);\n        manager = m;\n        unsub = m.subscribe((convs) => {\n            conversations.value = [...convs];\n            activeId.value = m.activeId;\n        });\n        await m.init();\n        activeId.value = m.activeId;\n        AparteConfig.setConversationManager(m);\n    };\n\n    return {\n        conversations,\n        activeConversations,\n        archivedConversations,\n        activeId,\n        activeConversation,\n        init,\n        createNew: (title?: string) => assert().createNew(title),\n        addMessage: (convId: string, message: AparteMessage) => assert().addMessage(convId, message),\n        updateMessages: (convId: string, messages: AparteMessage[]) => assert().updateMessages(convId, messages),\n        delete: (id: string) => assert().delete(id),\n        archive: (id: string) => assert().archive(id),\n        unarchive: (id: string) => assert().unarchive(id),\n    };\n}\n","<script setup lang=\"ts\">\nimport { ref, computed, watch, onMounted, onBeforeUnmount, toRaw } from 'vue';\nimport { applyElementProps, DEFAULT_UI_EVENTS } from '@aparte/core';\n\nconst p = defineProps<{\n  /** The custom element tag name (e.g. 'aparte-model-selector'). */\n  name: string;\n  /** Props to apply. Keys starting with `--` become CSS variables. */\n  props?: Record<string, unknown>;\n  /**\n   * Which custom events to forward through `elementEvent`. Defaults to the\n   * interactive aparté surface (DEFAULT_UI_EVENTS); pass your own list to listen to\n   * other events (e.g. ['aparte-composer-change'] for attachments).\n   */\n  events?: string[];\n}>();\n\nconst emit = defineEmits<{ elementEvent: [event: CustomEvent] }>();\n\n// A stable key so a fresh inline `:events` array doesn't thrash the element —\n// only a real change to the event names rebinds (mirrors React's evtsKey).\nconst evtsKey = computed(() => (p.events ?? DEFAULT_UI_EVENTS).join('|'));\n\nconst hostRef = ref<HTMLElement>();\nlet el: HTMLElement | null = null;\nlet cleanups: Array<() => void> = [];\n\n// Vue passes `toRaw` so objects are unwrapped from the reactive proxy before\n// reaching the plain custom element (a deep proxy breaks Maps/class internals).\nfunction applyProps() {\n  if (el) applyElementProps(el, p.props ?? {}, toRaw);\n}\n\nfunction create() {\n  if (!hostRef.value) return;\n  el = document.createElement(p.name);\n  applyProps();\n  for (const ev of evtsKey.value.split('|').filter(Boolean)) {\n    const listener = (e: Event) => emit('elementEvent', e as CustomEvent);\n    el.addEventListener(ev, listener);\n    cleanups.push(() => el?.removeEventListener(ev, listener));\n  }\n  hostRef.value.appendChild(el);\n}\n\nfunction destroy() {\n  for (const c of cleanups) c();\n  cleanups = [];\n  el?.remove();\n  el = null;\n}\n\nonMounted(create);\nonBeforeUnmount(destroy);\nwatch(() => p.name, () => { destroy(); create(); });\nwatch(evtsKey, () => { destroy(); create(); });\nwatch(() => p.props, applyProps, { deep: true });\n\ndefineExpose({\n  getElement: () => el,\n  callMethod: (methodName: string, ...args: unknown[]) => {\n    const fn = (el as unknown as Record<string, unknown>)?.[methodName];\n    return typeof fn === 'function' ? (fn as (...a: unknown[]) => unknown).apply(el, args) : undefined;\n  },\n});\n</script>\n\n<template>\n  <span ref=\"hostRef\" style=\"display: contents\"></span>\n</template>\n"],"names":["_createElementBlock","_createElementVNode","_renderSlot","_Fragment","_renderList","$slots","_openBlock"],"mappings":"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"}

package/dist/types.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Public types for the Vue wrapper — all re-exported from `@aparte/core`, the
+ * single source of truth. `AparteSendEventDetail` used to be re-declared here
+ * WITHOUT `targetId`, which the composer actually sends (multi-instance scoping);
+ * re-export the canonical one so the field isn't silently dropped from the type.
+ */
+export type { AparteMessage, AparteSegment, AparteTextSegment, AparteCodeSegment, AparteThinkingSegment, AparteTerminalSegment, AparteSendEventDetail, AparteActionEventDetail, } from '@aparte/core';
+/** Props of the `<AparteUi>` universal pass-through proxy. */
+export interface AparteUiProps {
+    /** The custom element tag name (e.g. 'aparte-model-selector'). */
+    name: string;
+    /** Props to apply. Keys starting with `--` become CSS variables. */
+    props?: Record<string, unknown>;
+    /**
+     * Which custom events to forward through `elementEvent`. Defaults to the
+     * interactive aparté surface (`DEFAULT_UI_EVENTS` from `@aparte/core`).
+     */
+    events?: string[];
+}
+/**
+ * The imperative surface `<AparteUi>` exposes (template ref) — the same
+ * `getElement`/`callMethod` contract on all four wrappers.
+ */
+export interface AparteUiHandle {
+    getElement<T extends HTMLElement = HTMLElement>(): T | null;
+    callMethod<T = unknown>(methodName: string, ...args: unknown[]): T | undefined;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,YAAY,EACR,aAAa,EACb,aAAa,EACb,iBAAiB,EACjB,iBAAiB,EACjB,qBAAqB,EACrB,qBAAqB,EACrB,qBAAqB,EACrB,uBAAuB,GAC1B,MAAM,cAAc,CAAC;AAEtB,8DAA8D;AAC9D,MAAM,WAAW,aAAa;IAC1B,kEAAkE;IAClE,IAAI,EAAE,MAAM,CAAC;IACb,oEAAoE;IACpE,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;CACrB;AAED;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC3B,UAAU,CAAC,CAAC,SAAS,WAAW,GAAG,WAAW,KAAK,CAAC,GAAG,IAAI,CAAC;IAC5D,UAAU,CAAC,CAAC,GAAG,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,CAAC,GAAG,SAAS,CAAC;CAClF"}

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@aparte/vue",
+  "version": "0.2.0-alpha.0",
+  "description": "Vue 3 wrapper for aparté — an ergonomic <AparteChat> component plus composables over the framework-agnostic web components.",
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "@aparte-workspace/source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "peerDependencies": {
+    "vue": "^3.5.0",
+    "@aparte/core": "0.2.0-alpha.0"
+  },
+  "devDependencies": {
+    "@vitejs/plugin-vue": "^5.0.0",
+    "@vue/test-utils": "^2.4.6",
+    "jsdom": "^22.1.0",
+    "typescript": "^5.4.0",
+    "vite": "^6.0.0",
+    "vue": "^3.5.0",
+    "vue-tsc": "^2.0.0",
+    "@aparte/core": "0.2.0-alpha.0"
+  },
+  "keywords": [
+    "vue",
+    "vue3",
+    "aparte",
+    "chat",
+    "ai",
+    "web-components"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/apartejs/aparte.git",
+    "directory": "packages/wrappers/vue"
+  },
+  "bugs": {
+    "url": "https://github.com/apartejs/aparte/issues"
+  },
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build && vue-tsc -b --emitDeclarationOnly --force",
+    "typecheck": "vue-tsc -b --emitDeclarationOnly --force",
+    "preview": "vite preview",
+    "test": "vitest",
+    "test:run": "vitest run",
+    "test:coverage": "vitest run --coverage"
+  }
+}