@artooi/agents-web-components 0.0.0-stage → 0.1.1

package/dist/ui/shell/theme_styles.d.ts

@@ -0,0 +1,2 @@
+export declare const THEME_STYLES: string;
+//# sourceMappingURL=theme_styles.d.ts.map

package/dist/ui/shell/theme_styles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"theme_styles.d.ts","sourceRoot":"","sources":["../../../src/ui/shell/theme_styles.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,YAAY,EAAE,MAS1B,CAAC"}

package/dist/ui/shell/token_styles.d.ts

@@ -0,0 +1,2 @@
+export declare const TOKEN_STYLES: string;
+//# sourceMappingURL=token_styles.d.ts.map

package/dist/ui/shell/token_styles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"token_styles.d.ts","sourceRoot":"","sources":["../../../src/ui/shell/token_styles.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,YAAY,EAAE,MA6d1B,CAAC"}

package/dist/ui/styles.d.ts

@@ -0,0 +1,2 @@
+export declare const STYLES: string;
+//# sourceMappingURL=styles.d.ts.map

package/dist/ui/styles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"styles.d.ts","sourceRoot":"","sources":["../../src/ui/styles.ts"],"names":[],"mappings":"AAyDA,eAAO,MAAM,MAAM,EAAE,MAoDX,CAAC"}

package/dist/ui/themes/classic_styles.d.ts

@@ -0,0 +1,2 @@
+export declare const CLASSIC_STYLES: string;
+//# sourceMappingURL=classic_styles.d.ts.map

package/dist/ui/themes/classic_styles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"classic_styles.d.ts","sourceRoot":"","sources":["../../../src/ui/themes/classic_styles.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,cAAc,EAAE,MA6B5B,CAAC"}

package/dist/ui/themes/classic_tokens.d.ts

@@ -0,0 +1,2 @@
+export declare const CLASSIC_TOKENS: string;
+//# sourceMappingURL=classic_tokens.d.ts.map

package/dist/ui/themes/classic_tokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"classic_tokens.d.ts","sourceRoot":"","sources":["../../../src/ui/themes/classic_tokens.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,cAAc,EAAE,MAgD5B,CAAC"}

package/dist/ui/themes/code_tokens.d.ts

@@ -0,0 +1,2 @@
+export declare const CODE_TOKENS: string;
+//# sourceMappingURL=code_tokens.d.ts.map

package/dist/ui/themes/code_tokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"code_tokens.d.ts","sourceRoot":"","sources":["../../../src/ui/themes/code_tokens.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,WAAW,EAAE,MAkBzB,CAAC"}

package/dist/ui/themes/ledger_styles.d.ts

@@ -0,0 +1,2 @@
+export declare const LEDGER_STYLES: string;
+//# sourceMappingURL=ledger_styles.d.ts.map

package/dist/ui/themes/ledger_styles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ledger_styles.d.ts","sourceRoot":"","sources":["../../../src/ui/themes/ledger_styles.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,aAAa,EAAE,MAuK3B,CAAC"}

package/dist/ui/themes/ledger_tokens.d.ts

@@ -0,0 +1,2 @@
+export declare const LEDGER_TOKENS: string;
+//# sourceMappingURL=ledger_tokens.d.ts.map

package/dist/ui/themes/ledger_tokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ledger_tokens.d.ts","sourceRoot":"","sources":["../../../src/ui/themes/ledger_tokens.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,aAAa,EAAE,MA+B3B,CAAC"}

package/dist/ui/themes/modern_styles.d.ts

@@ -0,0 +1,2 @@
+export declare const MODERN_STYLES: string;
+//# sourceMappingURL=modern_styles.d.ts.map

package/dist/ui/themes/modern_styles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"modern_styles.d.ts","sourceRoot":"","sources":["../../../src/ui/themes/modern_styles.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,aAAa,EAAE,MA2E3B,CAAC"}

package/dist/ui/themes/quiet_styles.d.ts

@@ -0,0 +1,2 @@
+export declare const QUIET_STYLES: string;
+//# sourceMappingURL=quiet_styles.d.ts.map

package/dist/ui/themes/quiet_styles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quiet_styles.d.ts","sourceRoot":"","sources":["../../../src/ui/themes/quiet_styles.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,YAAY,EAAE,MAiH1B,CAAC"}

package/dist/ui/themes/scheme_styles.d.ts

@@ -0,0 +1,2 @@
+export declare const SCHEME_STYLES: string;
+//# sourceMappingURL=scheme_styles.d.ts.map

package/dist/ui/themes/scheme_styles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheme_styles.d.ts","sourceRoot":"","sources":["../../../src/ui/themes/scheme_styles.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,aAAa,EAAE,MAwB3B,CAAC"}

package/dist/ui/themes/soft_styles.d.ts

@@ -0,0 +1,2 @@
+export declare const SOFT_STYLES: string;
+//# sourceMappingURL=soft_styles.d.ts.map

package/dist/ui/themes/soft_styles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"soft_styles.d.ts","sourceRoot":"","sources":["../../../src/ui/themes/soft_styles.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,WAAW,EAAE,MAmJzB,CAAC"}

package/dist/ui/themes/soft_tokens.d.ts

@@ -0,0 +1,2 @@
+export declare const SOFT_TOKENS: string;
+//# sourceMappingURL=soft_tokens.d.ts.map

package/dist/ui/themes/soft_tokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"soft_tokens.d.ts","sourceRoot":"","sources":["../../../src/ui/themes/soft_tokens.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,WAAW,EAAE,MA2BzB,CAAC"}

package/dist/ui/themes/theme_hosts.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The host selectors theme rules hang off, as one record so every theme
+ * module spells them the same way.
+ *
+ * Classic and code keep today's structure, so the structural rules the newer
+ * themes share apply to every element that wears neither. Quiet is the
+ * default, so its own structure applies to every element that wears no other
+ * built-in theme -- including one whose theme is a word the library does not
+ * know, which is how a host's own named theme starts from Quiet.
+ */
+export declare const THEME_HOST: {
+    readonly modern: ':host(:not([theme~="classic"], [theme~="code"]))';
+    readonly quiet: ':host(:not([theme~="classic"], [theme~="code"], [theme~="soft"], [theme~="ledger"]))';
+};
+//# sourceMappingURL=theme_hosts.d.ts.map

package/dist/ui/themes/theme_hosts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"theme_hosts.d.ts","sourceRoot":"","sources":["../../../src/ui/themes/theme_hosts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,eAAO,MAAM,UAAU;aACrB,MAAM,EAAE,kDAAkD;aAC1D,KAAK,EAAE,sFAAsF;CACrF,CAAC"}

package/dist/ui/transcript/answer_actions.d.ts

@@ -0,0 +1,50 @@
+import type { AgUiMessageIds } from "../../core/agui_client.js";
+import type { UiStrings } from "../ui_strings.js";
+/** What the answer actions need from the element that owns them. */
+export interface AnswerActionsHost {
+    /** The custom element: its `data-message-actions`, and where feedback is dispatched. */
+    readonly element: HTMLElement;
+    /** The resolved string table. */
+    readonly strings: () => UiStrings;
+    /** Retry the last turn, as the element's public `retryLastTurn` does. */
+    readonly retry: () => void;
+    /** The element's current conversation thread. */
+    readonly threadId: () => string;
+    /** Follow the transcript's foot, as every site that adds to it does. */
+    readonly follow: () => void;
+}
+/** A finished bubble that is not an answer, and so carries no rating. */
+interface Unrateable {
+    readonly rateable: false;
+}
+/**
+ * The action row under a finished answer -- copy, retry, feedback -- and the
+ * one row currently holding Retry.
+ *
+ * Owned one-to-one by an `<ag-ui-chat>`, and holding no state outside the
+ * instance.
+ */
+export declare class AnswerActions {
+    #private;
+    constructor(host: AnswerActionsHost);
+    /** Forget the row holding Retry, with the transcript it was in. */
+    forget(): void;
+    /**
+     * Give a finished assistant bubble its action row, and hand it Retry.
+     *
+     * Every finished bubble gets copy and feedback -- both are safe on a message
+     * of any age. Retry moves to the newest, because it is the only one where
+     * re-running answers the same question rather than rewriting history.
+     *
+     * `data-message-actions` subtracts from that. The row is built only when
+     * something survives to go in it: an empty row still takes its margin, still
+     * answers to the `message-actions` part, and still reads to a screen reader
+     * as a group of actions with none in it.
+     *
+     * `message` names the answer, which is what a rating is filed under; a bubble
+     * that is not an answer says so instead, and has no id to give.
+     */
+    attach(bubble: HTMLDivElement, message: AgUiMessageIds | Unrateable): void;
+}
+export {};
+//# sourceMappingURL=answer_actions.d.ts.map

package/dist/ui/transcript/answer_actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"answer_actions.d.ts","sourceRoot":"","sources":["../../../src/ui/transcript/answer_actions.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAIhE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAGlD,oEAAoE;AACpE,MAAM,WAAW,iBAAiB;IAChC,wFAAwF;IACxF,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC;IAC9B,iCAAiC;IACjC,QAAQ,CAAC,OAAO,EAAE,MAAM,SAAS,CAAC;IAClC,yEAAyE;IACzE,QAAQ,CAAC,KAAK,EAAE,MAAM,IAAI,CAAC;IAC3B,iDAAiD;IACjD,QAAQ,CAAC,QAAQ,EAAE,MAAM,MAAM,CAAC;IAChC,wEAAwE;IACxE,QAAQ,CAAC,MAAM,EAAE,MAAM,IAAI,CAAC;CAC7B;AAED,yEAAyE;AACzE,UAAU,UAAU;IAClB,QAAQ,CAAC,QAAQ,EAAE,KAAK,CAAC;CAC1B;AAED;;;;;;GAMG;AACH,qBAAa,aAAa;;IAWxB,YAAY,IAAI,EAAE,iBAAiB,EAElC;IAED,mEAAmE;IACnE,MAAM,IAAI,IAAI,CAEb;IAED;;;;;;;;;;;;;;OAcG;IACH,MAAM,CAAC,MAAM,EAAE,cAAc,EAAE,OAAO,EAAE,cAAc,GAAG,UAAU,GAAG,IAAI,CAuDzE;CAwCF"}

package/dist/ui/transcript/answer_stream.d.ts

@@ -0,0 +1,56 @@
+/** What the streamed answer needs from the element that owns it. */
+export interface AnswerStreamHost {
+    /** Append an empty assistant bubble to the transcript, and return it. */
+    readonly openBubble: () => HTMLDivElement;
+    /** The element's `allowImages`, read per render. */
+    readonly allowImages: () => boolean;
+    /** Keep the transcript at its foot, if the reader is there. */
+    readonly follow: () => void;
+}
+/**
+ * The assistant answer currently streaming: the bubble it streams into, the
+ * text the next frame will draw, and how many deltas it arrived in.
+ *
+ * Owned one-to-one by an `<ag-ui-chat>`, and holding no state outside the
+ * instance.
+ */
+export declare class AnswerStream {
+    #private;
+    constructor(host: AnswerStreamHost);
+    /** Text deltas the current answer has arrived in so far. */
+    get deltas(): number;
+    /**
+     * Count one delta received. Counted per delta received, not per render: the
+     * word reveal asks whether the answer *arrived* progressively, which
+     * coalescing renders must not change the answer to.
+     */
+    countDelta(): void;
+    /**
+     * Queue a render of the answer so far, at most one per frame.
+     *
+     * Each `TEXT_MESSAGE_CONTENT` event carries the *whole* accumulated answer,
+     * and drawing it means marked + DOMPurify over the entire document and a
+     * wholesale replacement of the bubble's subtree. Once per token that is
+     * quadratic in the answer's length — a long answer is agent-controlled, so
+     * an ordinary run becomes a progressively stalling tab — and every rebuild
+     * takes any selection or focus inside the bubble with it.
+     *
+     * A frame is the right grain: it is the fastest anything on screen can
+     * change anyway, so a burst of tokens costs one parse and the text still
+     * appears to flow rather than in visible chunks.
+     */
+    queue(buffer: string): void;
+    /** Render `buffer` into the streaming bubble now, dropping any queued frame. */
+    into(buffer: string): HTMLDivElement;
+    /**
+     * Close the current answer's streaming bubble.
+     *
+     * Draws a queued render first. A run that ends without a text end — a
+     * cancel, an error, a round boundary — leaves the last delta sitting in the
+     * queue, and simply dropping the bubble here would strand it: the partial
+     * answer the user stopped mid-sentence would lose its final tokens, or be an
+     * empty bubble above the stopped note.
+     */
+    end(): void;
+}
+//# sourceMappingURL=answer_stream.d.ts.map

package/dist/ui/transcript/answer_stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"answer_stream.d.ts","sourceRoot":"","sources":["../../../src/ui/transcript/answer_stream.ts"],"names":[],"mappings":"AAEA,oEAAoE;AACpE,MAAM,WAAW,gBAAgB;IAC/B,yEAAyE;IACzE,QAAQ,CAAC,UAAU,EAAE,MAAM,cAAc,CAAC;IAC1C,oDAAoD;IACpD,QAAQ,CAAC,WAAW,EAAE,MAAM,OAAO,CAAC;IACpC,+DAA+D;IAC/D,QAAQ,CAAC,MAAM,EAAE,MAAM,IAAI,CAAC;CAC7B;AAED;;;;;;GAMG;AACH,qBAAa,YAAY;;IAcvB,YAAY,IAAI,EAAE,gBAAgB,EAEjC;IAED,4DAA4D;IAC5D,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED;;;;OAIG;IACH,UAAU,IAAI,IAAI,CAEjB;IAED;;;;;;;;;;;;;OAaG;IACH,KAAK,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAU1B;IAED,gFAAgF;IAChF,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,cAAc,CAYnC;IAED;;;;;;;;OAQG;IACH,GAAG,IAAI,IAAI,CAKV;CAgBF"}

package/dist/ui/transcript/attachment_chip_styles.d.ts

@@ -0,0 +1,2 @@
+export declare const ATTACHMENT_CHIP_STYLES: string;
+//# sourceMappingURL=attachment_chip_styles.d.ts.map

package/dist/ui/transcript/attachment_chip_styles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attachment_chip_styles.d.ts","sourceRoot":"","sources":["../../../src/ui/transcript/attachment_chip_styles.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,sBAAsB,EAAE,MAgHpC,CAAC"}

package/dist/ui/transcript/attachment_chips.d.ts

@@ -0,0 +1,21 @@
+import type { AttachmentRef } from "../../core/attachment.js";
+/**
+ * Render the read-only attachment chips on a sent user message bubble and on
+ * restored history — one chip per ref with a type icon, filename, and human
+ * size. Static: no progress and no remove, both of which live in the composer
+ * tray.
+ */
+export declare function renderAttachmentChips(refs: readonly AttachmentRef[]): HTMLDivElement;
+/**
+ * A coarse type mark for a chip — image, PDF, text document, or generic file —
+ * as inline SVG markup rather than a character, so it matches the composer's
+ * SVG buttons in weight and takes the glyph size and `currentColor`, which
+ * emoji do not.
+ *
+ * The MIME string only selects among author-written constants and is never
+ * interpolated into one, so the result is safe to assign as markup.
+ */
+export declare function iconFor(mime: string): string;
+/** A compact human-readable byte size (e.g. `1.2 MB`). */
+export declare function formatBytes(bytes: number): string;
+//# sourceMappingURL=attachment_chips.d.ts.map

package/dist/ui/transcript/attachment_chips.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attachment_chips.d.ts","sourceRoot":"","sources":["../../../src/ui/transcript/attachment_chips.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAE9D;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,SAAS,aAAa,EAAE,GAAG,cAAc,CAQpF;AA4BD;;;;;;;;GAQG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAW5C;AAED,0DAA0D;AAC1D,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAajD"}

package/dist/ui/transcript/build_transcript.d.ts

@@ -0,0 +1,21 @@
+import type { UiStrings } from "../ui_strings.js";
+/** The transcript's parts, owned by the element, and what fills them. */
+export interface TranscriptOptions {
+    readonly messages: HTMLElement;
+    readonly jumpButton: HTMLButtonElement;
+    readonly emptyWrap: HTMLElement;
+    /** The greeting's text node, kept by the element so a new user name updates it. */
+    readonly greetingText: HTMLElement;
+    /** The starter chips, or `null` when the host configured none. */
+    readonly starters: HTMLElement | null;
+    readonly strings: UiStrings;
+}
+/**
+ * Ready the message list, its jump-to-latest control and the empty state.
+ *
+ * The empty state is built but not put into the list: the element mounts the
+ * scroller, the quote offer and the announcer first and appends it after, so
+ * the scroller's observers see the list fill exactly as they always have.
+ */
+export declare function buildTranscript(options: TranscriptOptions): void;
+//# sourceMappingURL=build_transcript.d.ts.map

package/dist/ui/transcript/build_transcript.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build_transcript.d.ts","sourceRoot":"","sources":["../../../src/ui/transcript/build_transcript.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAElD,yEAAyE;AACzE,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC;IAC/B,QAAQ,CAAC,UAAU,EAAE,iBAAiB,CAAC;IACvC,QAAQ,CAAC,SAAS,EAAE,WAAW,CAAC;IAChC,mFAAmF;IACnF,QAAQ,CAAC,YAAY,EAAE,WAAW,CAAC;IACnC,kEAAkE;IAClE,QAAQ,CAAC,QAAQ,EAAE,WAAW,GAAG,IAAI,CAAC;IACtC,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAC;CAC7B;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,iBAAiB,GAAG,IAAI,CA6ChE"}

package/dist/ui/transcript/greeting_styles.d.ts

@@ -0,0 +1,2 @@
+export declare const GREETING_STYLES: string;
+//# sourceMappingURL=greeting_styles.d.ts.map

package/dist/ui/transcript/greeting_styles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"greeting_styles.d.ts","sourceRoot":"","sources":["../../../src/ui/transcript/greeting_styles.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,eAAe,EAAE,MAwK7B,CAAC"}

package/dist/ui/transcript/groups_tool_steps.d.ts

@@ -0,0 +1,13 @@
+import type { ToolDisplayMode } from "../progress/tool_call_card.js";
+/**
+ * Whether a new tool call folds into a step group, given the element's
+ * `toolDisplay`.
+ *
+ * The display mode alone decides, whatever the theme: `grouped` (the default,
+ * and what an unknown value reads as) folds, and the four card modes keep
+ * per-call cards. Asked as each card is built, so switching to `grouped`
+ * folds only the calls drawn afterwards; switching away flattens the groups
+ * already drawn, which the shadow CSS does from the host attribute.
+ */
+export declare function groupsToolSteps(mode: ToolDisplayMode): boolean;
+//# sourceMappingURL=groups_tool_steps.d.ts.map

package/dist/ui/transcript/groups_tool_steps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"groups_tool_steps.d.ts","sourceRoot":"","sources":["../../../src/ui/transcript/groups_tool_steps.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAErE;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,eAAe,GAAG,OAAO,CAE9D"}

package/dist/ui/transcript/message_action_styles.d.ts

@@ -0,0 +1,2 @@
+export declare const MESSAGE_ACTION_STYLES: string;
+//# sourceMappingURL=message_action_styles.d.ts.map

package/dist/ui/transcript/message_action_styles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message_action_styles.d.ts","sourceRoot":"","sources":["../../../src/ui/transcript/message_action_styles.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,qBAAqB,EAAE,MAuJnC,CAAC"}

package/dist/ui/transcript/message_actions.d.ts

@@ -0,0 +1,74 @@
+import type { UiStrings } from "../ui_strings.js";
+/** What an action bar can do, beyond copying. */
+export interface MessageActionsOptions {
+    /** Localized strings. */
+    strings: UiStrings;
+    /**
+     * The text Copy puts on the clipboard. Absent means no copy button.
+     *
+     * A function rather than a string because a bubble's content is rewritten
+     * while it streams. Each button's option is also the statement that the
+     * button belongs, so no second flag can disagree with it.
+     */
+    text?: () => string;
+    /**
+     * The rich flavour to copy alongside `text`, as an HTML fragment. Absent
+     * means plain text only.
+     *
+     * It is what makes a copied table paste as a table: a spreadsheet or a chat
+     * client reads `text/html` when offered and falls back to the plain flavour.
+     */
+    html?: () => string;
+    /**
+     * Report a rating for this message. Absent means no feedback buttons.
+     *
+     * The component stores nothing: a rating is the host's to keep, and a
+     * write-only table nobody reads is not worth a schema.
+     */
+    onFeedback?: (rating: "up" | "down") => void;
+}
+/**
+ * Give one finished message bubble its row of actions.
+ *
+ * **Finished** is load-bearing. A streaming bubble reassigns its `innerHTML` on
+ * every delta, so anything attached mid-stream is discarded and rebuilt for
+ * each one -- the same constraint `attachCopyButtons` records, one level up.
+ *
+ * Retry is deliberately **not** here: it belongs to the last turn only, so the
+ * element owns it and moves it as the transcript grows. Everything on this bar
+ * is safe to offer on any message, however old.
+ *
+ * Idempotent -- a bubble already given a bar is skipped, so a re-render or a
+ * second call cannot stack rows.
+ *
+ * Passing neither `text` nor `onFeedback` builds an empty row; the element
+ * skips the call when a host has turned both off.
+ */
+export declare function attachMessageActions(bubble: HTMLElement, options: MessageActionsOptions): void;
+/**
+ * The empty action row on `bubble`, created if it has none yet.
+ *
+ * Shared so a bubble that wants *only* Retry -- a failed run, which has nothing
+ * worth copying and nothing to rate -- gets the same row, the same part name
+ * and the same accessible grouping as every other message, rather than a
+ * second thing that looks like one.
+ */
+export declare function messageActionBar(bubble: HTMLElement, strings: UiStrings): HTMLElement;
+/**
+ * Build one action button, labelled for screen readers rather than by glyph.
+ *
+ * `icon` is icon markup rather than a text glyph: the copy mark in particular
+ * has no font behind it on most systems.
+ *
+ * The label is carried three ways, and each has a reader the others miss:
+ * `aria-label` for assistive technology, `title` for the browser's own
+ * tooltip, and `data-tooltip` for the one this component draws. The last is
+ * not redundant with the second -- a `title` never appears on keyboard focus,
+ * so without it a keyboard user has no way to see what the control does.
+ *
+ * The icon sits in its own part, so a host can restyle or replace it. A slot
+ * would be the better channel and cannot be used here: these repeat once per
+ * message, and a named slot can only be filled once.
+ */
+export declare function messageActionButton(modifier: string, label: string, icon: string): HTMLButtonElement;
+//# sourceMappingURL=message_actions.d.ts.map

package/dist/ui/transcript/message_actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message_actions.d.ts","sourceRoot":"","sources":["../../../src/ui/transcript/message_actions.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAKlD,iDAAiD;AACjD,MAAM,WAAW,qBAAqB;IACpC,yBAAyB;IACzB,OAAO,EAAE,SAAS,CAAC;IACnB;;;;;;OAMG;IACH,IAAI,CAAC,EAAE,MAAM,MAAM,CAAC;IACpB;;;;;;OAMG;IACH,IAAI,CAAC,EAAE,MAAM,MAAM,CAAC;IACpB;;;;;OAKG;IACH,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,IAAI,GAAG,MAAM,KAAK,IAAI,CAAC;CAC9C;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,WAAW,EAAE,OAAO,EAAE,qBAAqB,GAAG,IAAI,CAe9F;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,WAAW,EAAE,OAAO,EAAE,SAAS,GAAG,WAAW,CAmBrF;AAQD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,GACX,iBAAiB,CAcnB"}

package/dist/ui/transcript/message_styles.d.ts

@@ -0,0 +1,2 @@
+export declare const MESSAGE_STYLES: string;
+//# sourceMappingURL=message_styles.d.ts.map

package/dist/ui/transcript/message_styles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message_styles.d.ts","sourceRoot":"","sources":["../../../src/ui/transcript/message_styles.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,cAAc,EAAE,MAmQ5B,CAAC"}

package/dist/ui/transcript/render_markdown.d.ts

@@ -0,0 +1,40 @@
+import { type Config } from "dompurify";
+/**
+ * The sanitiser's declared allowlist — and, because {@link harden} runs inside
+ * the sanitiser rather than after it, its *effective* one too.
+ *
+ * `ALLOW_DATA_ATTR` and `ALLOW_ARIA_ATTR` default to `true`, which would admit
+ * every `data-*` and `aria-*` attribute on top of the five named above. Both
+ * matter here: the cards drive their resolved / expanded / status appearance off
+ * `[data-resolved]`, `[data-status]` and `[data-expanded]`, and an `aria-label`
+ * on model output makes a screen reader announce something other than what is on
+ * screen. Turning them off is what makes the declared list the real one.
+ *
+ * Exported so a test can assert the returned markup is a fixed point of it.
+ */
+export declare const SANITIZE_CONFIG: Config;
+/** {@link SANITIZE_CONFIG} plus the images a host opts into. */
+export declare const SANITIZE_CONFIG_WITH_IMAGES: Config;
+/** Options for {@link renderMarkdown}. */
+export interface RenderMarkdownOptions {
+    /**
+     * Permit `<img>` tags (and their `src`/`alt`/`width`/`height` attributes) in
+     * the sanitised output. Off by default; see the exfiltration note on the
+     * allowlist above. Only enable for trusted content sources.
+     */
+    readonly allowImages?: boolean;
+}
+/**
+ * Render markdown (and any embedded raw HTML) to a sanitised HTML string.
+ *
+ * Markdown syntax and literal HTML share one path: `marked` emits HTML, then
+ * DOMPurify strips everything outside {@link SANITIZE_CONFIG} — scripts, event
+ * handlers, `javascript:` URLs, `data-*`/`aria-*`, and every class but a code
+ * fence's `language-*` hint. Links come out with `target="_blank"` and
+ * `rel="noopener noreferrer"`.
+ *
+ * The returned string is the sanitiser's own output, trimmed. Nothing edits it
+ * afterwards, so what a caller inserts is what DOMPurify approved.
+ */
+export declare function renderMarkdown(text: string, options?: RenderMarkdownOptions): string;
+//# sourceMappingURL=render_markdown.d.ts.map

package/dist/ui/transcript/render_markdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render_markdown.d.ts","sourceRoot":"","sources":["../../../src/ui/transcript/render_markdown.ts"],"names":[],"mappings":"AAEA,OAAkB,EAAE,KAAK,MAAM,EAA8B,MAAM,WAAW,CAAC;AA6D/E;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,eAAe,EAAE,MAK7B,CAAC;AAEF,gEAAgE;AAChE,eAAO,MAAM,2BAA2B,EAAE,MAIzC,CAAC;AAgEF,0CAA0C;AAC1C,MAAM,WAAW,qBAAqB;IACpC;;;;OAIG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC;CAChC;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,qBAAqB,GAAG,MAAM,CAMpF"}

package/dist/ui/transcript/render_or_warn.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Call a consumer's renderer, turning a throw into "nothing drawn".
+ *
+ * `render` is consumer code -- a host's activity renderer, a tool's `render` --
+ * and both call sites run inside the history replay, where a throw abandons the
+ * loop and takes every later turn of the transcript with it -- silently, and
+ * again on every reload. One thing that fails to draw is worth losing; the rest
+ * of the conversation is not. Reported so the failure is findable rather than
+ * merely survived.
+ *
+ * @param render - The consumer's renderer, already bound to its input.
+ * @param subject - What was being drawn, for the warning: `tool <name>` or
+ *   `activity <type>`.
+ */
+export declare function renderOrWarn(render: () => Node | null, subject: string): Node | null;
+//# sourceMappingURL=render_or_warn.d.ts.map

package/dist/ui/transcript/render_or_warn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render_or_warn.d.ts","sourceRoot":"","sources":["../../../src/ui/transcript/render_or_warn.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,IAAI,GAAG,IAAI,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAOpF"}

package/dist/ui/transcript/reveal_words.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Wrap each word under ``root`` in `<span class="word" style="--ag-ui-word-index: N">`
+ * so CSS can reveal them one-by-one (staggered by the index). Whitespace is
+ * preserved as plain text. Used for the `word` text-animation mode on a
+ * completed assistant message; pure DOM, idempotent enough to re-run.
+ */
+export declare function wrapWords(root: HTMLElement): void;
+//# sourceMappingURL=reveal_words.d.ts.map

package/dist/ui/transcript/reveal_words.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reveal_words.d.ts","sourceRoot":"","sources":["../../../src/ui/transcript/reveal_words.ts"],"names":[],"mappings":"AAWA;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,CAuBjD"}

package/dist/ui/transcript/starter_chips.d.ts

@@ -0,0 +1,21 @@
+import type { UiStrings } from "../ui_strings.js";
+/**
+ * The prompts offered on an empty transcript, from `element`'s `data-starters`.
+ *
+ * Different from the suggestion chips a run pushes, which are follow-ups to
+ * something already said. These answer the blank-page question instead, and
+ * they are the host's rather than the model's -- only the host knows what its
+ * page is for. Shares the renderer, the count and the length limit, because
+ * two rows of prompt chips that behaved differently would be the harder
+ * thing to explain.
+ *
+ * Read once at connect: it is content for a state the widget is in before
+ * anything happens, and a host that wants it to change has `slot="empty"`.
+ *
+ * Parses the attribute itself rather than through the element's JSON attribute
+ * reader, because the warning is its own: it says no starters are shown and
+ * gives an example of the shape, where the shared one says a built-in default
+ * is in use, which for this attribute there is not.
+ */
+export declare function renderStarterChips(element: Element, strings: UiStrings, onPick: (prompt: string) => void): HTMLElement | null;
+//# sourceMappingURL=starter_chips.d.ts.map

package/dist/ui/transcript/starter_chips.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"starter_chips.d.ts","sourceRoot":"","sources":["../../../src/ui/transcript/starter_chips.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAGlD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,SAAS,EAClB,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,GAC/B,WAAW,GAAG,IAAI,CAgBpB"}

package/dist/ui/transcript/stick_to_bottom.d.ts

@@ -0,0 +1,55 @@
+/** A transcript that follows new content, unless the reader has other ideas. */
+export interface StickToBottom {
+    /**
+     * New content arrived. Scrolls to the bottom only while following, so
+     * reading older messages during a run is no longer undone on the next token.
+     */
+    readonly follow: () => void;
+    /** Go to the bottom and resume following, whatever the reader was doing. */
+    readonly jump: () => void;
+    /** Whether the transcript is currently following new content. */
+    readonly following: () => boolean;
+    readonly dispose: () => void;
+}
+export interface StickToBottomOptions {
+    /** The scrolling element -- the message list. */
+    readonly viewport: HTMLElement;
+    /**
+     * Called whenever the answer to "should a jump-to-latest affordance show?"
+     * changes. True means the reader has scrolled away *and* has since missed
+     * something; scrolling up through a settled transcript is not a reason to
+     * nag.
+     */
+    readonly onMissedContent: (missed: boolean) => void;
+}
+/**
+ * Follow the foot of a scrolling transcript, and stop when the reader scrolls
+ * away.
+ *
+ * Before this, eleven separate sites assigned `scrollTop = scrollHeight`
+ * unconditionally and nothing anywhere listened for a `scroll` event -- so
+ * nothing knew the reader had scrolled up, and scrolling back through a run was
+ * undone by the next token. Stick-to-bottom with a jump-to-latest affordance is
+ * a named primitive elsewhere for exactly this reason: shadcn ships it as
+ * `MessageScroller`, AI Elements as `ConversationScrollButton`.
+ *
+ * **Telling a reader's scroll from our own is the whole problem**, and the
+ * answer here is that it does not have to be told. A programmatic scroll only
+ * ever happens while already following, and it lands at the bottom, so the
+ * `scroll` event it provokes recomputes "at the bottom" as true and changes
+ * nothing. A reader's scroll is the only kind that can move the answer.
+ *
+ * A `ResizeObserver` covers the case scroll events cannot see: the *viewport*
+ * changing size. Resizing the panel, or the keyboard opening on a phone, moves
+ * the foot without anything scrolling and without any content arriving, so a
+ * pinned transcript would silently come unpinned.
+ *
+ * ⚠ It does **not** cover content that grows after insertion -- an image
+ * decoding, a chart laying out. A `ResizeObserver` on a scroll container does
+ * not fire when its `scrollHeight` changes, so catching that means observing
+ * every child, and the payoff is one late nudge in a case the reader can fix by
+ * scrolling. Insertion itself is covered: every site that adds to the
+ * transcript calls {@link StickToBottom.follow}.
+ */
+export declare function createStickToBottom({ viewport, onMissedContent, }: StickToBottomOptions): StickToBottom;
+//# sourceMappingURL=stick_to_bottom.d.ts.map

package/dist/ui/transcript/stick_to_bottom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stick_to_bottom.d.ts","sourceRoot":"","sources":["../../../src/ui/transcript/stick_to_bottom.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAChF,MAAM,WAAW,aAAa;IAC5B;;;OAGG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,IAAI,CAAC;IAC5B,4EAA4E;IAC5E,QAAQ,CAAC,IAAI,EAAE,MAAM,IAAI,CAAC;IAC1B,iEAAiE;IACjE,QAAQ,CAAC,SAAS,EAAE,MAAM,OAAO,CAAC;IAClC,QAAQ,CAAC,OAAO,EAAE,MAAM,IAAI,CAAC;CAC9B;AAED,MAAM,WAAW,oBAAoB;IACnC,iDAAiD;IACjD,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC;IAC/B;;;;;OAKG;IACH,QAAQ,CAAC,eAAe,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,IAAI,CAAC;CACrD;AAWD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,mBAAmB,CAAC,EAClC,QAAQ,EACR,eAAe,GAChB,EAAE,oBAAoB,GAAG,aAAa,CA0DtC"}

package/dist/ui/transcript/suggestion_chips.d.ts

@@ -0,0 +1,29 @@
+import type { UiStrings } from "../ui_strings.js";
+/**
+ * Most prompts one push may draw.
+ *
+ * **Keep in step with `MAX_SUGGESTIONS` in django-ag-ui's
+ * `agent/suggestions_activity.py`**, which raises past it. Mirroring is the
+ * whole point: this side silently draws no more than its limit and has no
+ * channel to report the difference, so a producer that does not know the same
+ * number ships suggestions that never appear. That is the hole the chart bounds
+ * exist to close, and it was found there by shipping it.
+ */
+export declare const MAX_SUGGESTIONS = 4;
+/** Longest one prompt may be. Mirrored for the same reason as the count. */
+export declare const MAX_SUGGESTION_CHARS = 120;
+/** The `prompts` a `suggestions` activity carries, or `null` when it carries none. */
+export declare function suggestionPrompts(content: unknown): string[] | null;
+/**
+ * Draw follow-up prompts as chips that send themselves when clicked.
+ *
+ * Returns `null` when nothing survives, which is the registry's signal to draw
+ * nothing rather than an empty row -- the same contract the chart renderer uses
+ * for a spec it cannot draw.
+ *
+ * Buttons rather than links or list items: each one performs an action in the
+ * page, and the thing it sends is the label, so the accessible name is the
+ * prompt itself and needs no `aria-label` restating it.
+ */
+export declare function renderSuggestionChips(content: unknown, strings: UiStrings, onPick: (prompt: string) => void): HTMLElement | null;
+//# sourceMappingURL=suggestion_chips.d.ts.map