@clivly/chat-widget 0.4.0 → 0.7.0

package/README.md

@@ -68,6 +68,7 @@ It exports:
 - `mountChatWidgetScript()`
 - `autoMountChatWidgetScript()`
 - `MountChatWidgetOptions`
+- `ChatWidgetMount`
 - `ScriptMountResult`
 
 ### `@clivly/chat-widget/script`
@@ -79,6 +80,71 @@ This entry maps to the generated global/browser artifact:
 Use it for script-tag delivery, CDN-style consumption, or any future server path
 that serves the bundled widget directly.
 
+## Theming
+
+The widget ships light and dark palettes and follows the host app by default.
+For integration recipes (Tailwind, next-themes, a custom toggle) see
+[the guide's theming section](../../docs/guides/adding-the-chat-widget.md#theming).
+
+### `theme`
+
+| Value | Behaviour |
+| --- | --- |
+| `"auto"` *(default)* | Follows the host: `data-theme="dark"`/`"light"` on `<html>`, then a `dark`/`light` class on `<html>`, then `prefers-color-scheme`. Re-resolves live. |
+| `"light"` / `"dark"` | Pinned. Host signals are ignored and nothing is observed. |
+
+Set it as a prop (`<ChatWidget theme="dark" />`), as `data-theme` on the script
+tag, or as `theme` in `mountChatWidget()` options. An unrecognised
+`data-theme` value falls back to `"auto"` rather than throwing.
+
+`mountChatWidgetScript()` also returns `setTheme(theme)` for hosts whose toggle
+does not touch `<html>`:
+
+```ts
+const { setTheme } = mountChatWidgetScript(script);
+setTheme("dark");   // pin
+setTheme("auto");   // hand control back to the host
+```
+
+The resolved theme is applied as `data-clivly-theme="light|dark"` on the widget
+root, together with `color-scheme`, so native scrollbars, autofill, and the
+caret follow the panel.
+
+### Palette tokens
+
+Every colour reads through a CSS custom property. React hosts can override any
+of them inline — inline declarations beat both palette rules, so no specificity
+work is needed:
+
+```tsx
+<ChatWidget style={{ "--clivly-chat-panel": "#0b0f19" }} widgetId="support" />
+```
+
+| Token | Light | Dark |
+| --- | --- | --- |
+| `--clivly-chat-accent` | `#185adb` | `#4f8cff` |
+| `--clivly-chat-accent-contrast` | `#ffffff` | `#0b1220` |
+| `--clivly-chat-panel` | `#ffffff` | `#111827` |
+| `--clivly-chat-input` | `transparent` | `#0b1220` |
+| `--clivly-chat-border` | `#d6dde8` | `#2a3546` |
+| `--clivly-chat-text` | `#132238` | `#e8edf5` |
+| `--clivly-chat-muted` | `#60738a` | `#93a2b8` |
+| `--clivly-chat-visitor` | `#ecf3ff` | `#1e3a6b` |
+| `--clivly-chat-operator` | `#f5f7fa` | `#1b2534` |
+| `--clivly-chat-shadow` | `rgba(19, 34, 56, 0.18)` | `rgba(0, 0, 0, 0.5)` |
+| `--clivly-chat-error-bg` | `#fff1f1` | `#2c1618` |
+| `--clivly-chat-error-border` | `#f2c2c2` | `#5c2a2e` |
+| `--clivly-chat-error-text` | `#9f2d2d` | `#ffb4b4` |
+
+The widget record's `brandColor` overrides `--clivly-chat-accent` in **both**
+themes — the widget will not silently lighten your brand. If your brand colour
+is very dark it will be low-contrast on the dark panel; pick a lighter accent,
+or override the token per theme in a React host.
+
+Deep per-token overrides are not available on the script-tag path: it mounts
+into a Shadow DOM, so host CSS cannot reach the widget's internals. Use
+`brandColor` and the two themes there.
+
 ## Session bootstrap shape
 
 The widget expects a session bootstrap endpoint that returns a
@@ -123,11 +189,22 @@ The `browser` and `browser-mount` outputs are built as standalone entrypoints.
 
 ## Host-side pairing
 
-The intended host-side SDK helper lives in `@clivly/sdk`:
+The host-side session handler is the bridge between a backend holding
+`CLIVLY_API_KEY` and the widget's `sessionUrl`. Import it from `clivly/sdk`,
+which is available from the `clivly` package `clivly init` already installs:
 
 ```ts
-import { createChatSessionHandler } from "@clivly/sdk";
+import { createChatSessionHandler } from "clivly/sdk";
+
+export const POST = createChatSessionHandler({
+  apiKey: process.env.CLIVLY_API_KEY,
+});
 ```
 
-That handler is the expected bridge between a host backend holding
-`CLIVLY_API_KEY` and the widget's `sessionUrl`.
+`@clivly/sdk` exports the same handler if you depend on it directly. Don't import
+from `clivly` (the package root) — that entry is the CLI and is Node-only.
+
+Use the handler rather than hand-writing the proxy: it puts `origin` in the
+request body (the backend requires it there, and only falls back to the `Origin`
+header), accepts `visitorToken: null` for a first-time visitor, and turns an
+unreachable Clivly into a JSON `502` instead of a thrown `fetch`.

package/dist/browser-mount.cjs

@@ -2,21 +2,162 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 let react_dom_client = require("react-dom/client");
 let react = require("react");
 let react_jsx_runtime = require("react/jsx-runtime");
+//#region src/theme.ts
+const DARK_MEDIA_QUERY = "(prefers-color-scheme: dark)";
+/** The attribute set by next-themes, daisyUI, and most `data-*` theme setups. */
+const THEME_ATTRIBUTE = "data-theme";
+/** Attributes worth re-resolving on. Anything else on `<html>` is noise. */
+const OBSERVED_ATTRIBUTES = ["class", THEME_ATTRIBUTE];
+function isResolvedTheme(value) {
+	return value === "dark" || value === "light";
+}
+/**
+* The host's explicit signals, in precedence order: a `data-theme` attribute
+* beats a class, because a host that sets both is using the attribute as the
+* source of truth and the class as a styling convenience.
+*
+* Both conventions are checked for `light` as well as `dark`. A host that says
+* `class="light"` on an OS-dark machine means it, and the explicit signal
+* should win over the OS preference below it.
+*/
+function readHostTheme(root) {
+	const attribute = root.getAttribute(THEME_ATTRIBUTE);
+	if (isResolvedTheme(attribute)) return attribute;
+	if (root.classList.contains("dark")) return "dark";
+	if (root.classList.contains("light")) return "light";
+	return null;
+}
+function prefersDark(view) {
+	return view.matchMedia?.(DARK_MEDIA_QUERY).matches ?? false;
+}
+function defaultRoot() {
+	return typeof document === "undefined" ? null : document.documentElement;
+}
+function defaultView() {
+	return typeof window === "undefined" ? null : window;
+}
+/**
+* Resolve a requested theme to the one the widget should actually paint.
+*
+* Falls back to `light` when there is nothing to read — during SSR there is no
+* document, and guessing dark would flash the wrong palette on hydration for
+* the majority of pages.
+*/
+function resolveTheme(theme, { root = defaultRoot(), view = defaultView() } = {}) {
+	if (theme !== "auto") return theme;
+	const hostTheme = root ? readHostTheme(root) : null;
+	if (hostTheme) return hostTheme;
+	if (view && prefersDark(view)) return "dark";
+	return "light";
+}
+/**
+* Watch both host signals and call `onChange` whenever the resolved theme
+* changes. Returns an unsubscribe function.
+*
+* An explicit `light`/`dark` subscribes to nothing — there is no signal that
+* could change the answer — so callers can pass any theme without branching.
+*/
+function observeTheme(theme, onChange, { root = defaultRoot(), view = defaultView() } = {}) {
+	if (theme !== "auto") return () => {};
+	let current = resolveTheme(theme, {
+		root,
+		view
+	});
+	const publish = () => {
+		const next = resolveTheme(theme, {
+			root,
+			view
+		});
+		if (next !== current) {
+			current = next;
+			onChange(next);
+		}
+	};
+	const teardowns = [];
+	if (root && typeof MutationObserver !== "undefined") {
+		const observer = new MutationObserver(publish);
+		observer.observe(root, {
+			attributeFilter: OBSERVED_ATTRIBUTES,
+			attributes: true
+		});
+		teardowns.push(() => {
+			observer.disconnect();
+		});
+	}
+	const media = view?.matchMedia?.(DARK_MEDIA_QUERY);
+	if (media) {
+		if (media.addEventListener) {
+			media.addEventListener("change", publish);
+			teardowns.push(() => {
+				media.removeEventListener("change", publish);
+			});
+		} else if (media.addListener) {
+			media.addListener(publish);
+			teardowns.push(() => {
+				media.removeListener(publish);
+			});
+		}
+	}
+	return () => {
+		for (const teardown of teardowns) teardown();
+	};
+}
+/**
+* Narrow an untrusted string — a `data-theme` script attribute, a `setTheme`
+* call from plain JS — to a theme, falling back to `auto`.
+*/
+function parseTheme(value) {
+	if (value === "auto" || value === "dark" || value === "light") return value;
+	return "auto";
+}
+//#endregion
 //#region src/chat-widget.tsx
+const DELIVERY_LABELS = {
+	failed: "Failed to send",
+	pending: "Sending…",
+	sent: null
+};
 const WIDGET_STYLES = `
 .clivly-chat-widget, .clivly-chat-widget * { box-sizing: border-box; }
 .clivly-chat-widget {
   --clivly-chat-accent: #185adb;
+  --clivly-chat-accent-contrast: #ffffff;
   --clivly-chat-panel: #ffffff;
+  --clivly-chat-input: transparent;
   --clivly-chat-border: #d6dde8;
   --clivly-chat-text: #132238;
   --clivly-chat-muted: #60738a;
   --clivly-chat-visitor: #ecf3ff;
   --clivly-chat-operator: #f5f7fa;
+  --clivly-chat-shadow: rgba(19, 34, 56, 0.18);
+  --clivly-chat-error-bg: #fff1f1;
+  --clivly-chat-error-border: #f2c2c2;
+  --clivly-chat-error-text: #9f2d2d;
   color: var(--clivly-chat-text);
+  color-scheme: light;
   font-family: ui-sans-serif, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
   position: relative;
 }
+/* Dark is a pure token override — every rule below reads through a variable, so
+   the palette is the only thing that changes between themes. The color-scheme
+   declaration carries the theme to the parts of the UI that CSS cannot reach:
+   native scrollbars, autofill backgrounds, and the caret. */
+.clivly-chat-widget[data-clivly-theme="dark"] {
+  --clivly-chat-accent: #4f8cff;
+  --clivly-chat-accent-contrast: #0b1220;
+  --clivly-chat-panel: #111827;
+  --clivly-chat-input: #0b1220;
+  --clivly-chat-border: #2a3546;
+  --clivly-chat-text: #e8edf5;
+  --clivly-chat-muted: #93a2b8;
+  --clivly-chat-visitor: #1e3a6b;
+  --clivly-chat-operator: #1b2534;
+  --clivly-chat-shadow: rgba(0, 0, 0, 0.5);
+  --clivly-chat-error-bg: #2c1618;
+  --clivly-chat-error-border: #5c2a2e;
+  --clivly-chat-error-text: #ffb4b4;
+  color-scheme: dark;
+}
 .clivly-chat-widget button,
 .clivly-chat-widget input,
 .clivly-chat-widget textarea {
@@ -27,7 +168,7 @@ const WIDGET_STYLES = `
   background: var(--clivly-chat-accent);
   border: 0;
   border-radius: 999px;
-  color: white;
+  color: var(--clivly-chat-accent-contrast);
   cursor: pointer;
   display: inline-flex;
   gap: 0.5rem;
@@ -37,7 +178,7 @@ const WIDGET_STYLES = `
   background: var(--clivly-chat-panel);
   border: 1px solid var(--clivly-chat-border);
   border-radius: 1rem;
-  box-shadow: 0 24px 80px rgba(19, 34, 56, 0.18);
+  box-shadow: 0 24px 80px var(--clivly-chat-shadow);
   display: grid;
   grid-template-rows: auto 1fr auto;
   height: min(44rem, 75vh);
@@ -140,37 +281,54 @@ const WIDGET_STYLES = `
 }
 .clivly-chat-widget__input,
 .clivly-chat-widget__textarea {
+  background: var(--clivly-chat-input);
   border: 1px solid var(--clivly-chat-border);
   border-radius: 0.8rem;
+  color: inherit;
   min-width: 0;
   padding: 0.75rem 0.85rem;
 }
+.clivly-chat-widget__input::placeholder,
+.clivly-chat-widget__textarea::placeholder {
+  color: var(--clivly-chat-muted);
+}
 .clivly-chat-widget__textarea {
   min-height: 5.5rem;
   resize: vertical;
 }
 .clivly-chat-widget__actions {
+  align-items: center;
   display: flex;
   gap: 0.75rem;
   justify-content: space-between;
 }
+/* The subtitle is the only part that may reflow; without min-width the flex
+   default (min-content) lets it push the button below its intrinsic width. */
+.clivly-chat-widget__actions .clivly-chat-widget__subtitle {
+  min-width: 0;
+}
 .clivly-chat-widget__button {
   background: var(--clivly-chat-accent);
   border: 0;
   border-radius: 0.8rem;
-  color: white;
+  color: var(--clivly-chat-accent-contrast);
   cursor: pointer;
+  flex: 0 0 auto;
+  font: inherit;
+  font-weight: 600;
+  line-height: 1.2;
   padding: 0.75rem 0.95rem;
+  white-space: nowrap;
 }
 .clivly-chat-widget__button[disabled] {
   cursor: not-allowed;
   opacity: 0.55;
 }
 .clivly-chat-widget__error {
-  background: #fff1f1;
-  border: 1px solid #f2c2c2;
+  background: var(--clivly-chat-error-bg);
+  border: 1px solid var(--clivly-chat-error-border);
   border-radius: 0.8rem;
-  color: #9f2d2d;
+  color: var(--clivly-chat-error-text);
   font-size: 0.875rem;
   padding: 0.75rem;
 }
@@ -182,6 +340,13 @@ const WIDGET_STYLES = `
 }
 `;
 const DEFAULT_STORAGE = typeof window === "undefined" ? void 0 : window.localStorage;
+function sessionDisplayName(session) {
+	return session.contact?.name ?? "You";
+}
+function sessionSummaryText(session, fallback) {
+	if (!session) return fallback;
+	return session.contact ? `${session.contact.name} • ${session.contact.email}` : "Verified visitor";
+}
 function createLocalMessage(message, delivery = "sent") {
 	return {
 		...message,
@@ -232,14 +397,93 @@ function markMessageFailed(messages, clientMessageId) {
 function sortMessages(messages) {
 	return [...messages].sort((left, right) => left.createdAt.localeCompare(right.createdAt));
 }
-function useThemeStyle(session) {
+function useThemeStyle(session, style) {
 	return (0, react.useMemo)(() => {
 		const brandColor = session?.widget.config.brandColor ?? null;
-		if (!brandColor) return;
-		return { ["--clivly-chat-accent"]: brandColor };
-	}, [session?.widget.config.brandColor]);
+		if (!brandColor) return style;
+		return {
+			["--clivly-chat-accent"]: brandColor,
+			...style
+		};
+	}, [session?.widget.config.brandColor, style]);
 }
-function ChatWidget({ className, createTransport, getSession, initiallyOpen = false, launcherLabel = "Chat with us", storage = DEFAULT_STORAGE, widgetId }) {
+/**
+* Track the theme the widget should paint.
+*
+* The initial value is resolved synchronously so the first paint is already
+* correct — deferring it to an effect would flash light on a dark page.
+*/
+function useResolvedTheme(theme) {
+	const [resolved, setResolved] = (0, react.useState)(() => resolveTheme(theme));
+	(0, react.useEffect)(() => {
+		setResolved(resolveTheme(theme));
+		return observeTheme(theme, setResolved);
+	}, [theme]);
+	return resolved;
+}
+/**
+* Reduce one socket event into widget state.
+*
+* Lives at module scope rather than inside the connect effect so the wire
+* protocol reads as a single unit, and so `ChatWidget` stays inside the
+* cognitive-complexity budget.
+*/
+function applyServerEvent(event, { setError, setIsReady, setMessages }) {
+	switch (event.type) {
+		case "conversation.snapshot":
+			setMessages(sortMessages(event.messages.map((message) => createLocalMessage(message))));
+			return;
+		case "error":
+			setError(event.message);
+			return;
+		case "message.ack":
+			setMessages((currentMessages) => sortMessages(replacePendingMessage(currentMessages, event.clientMessageId, event.message)));
+			return;
+		case "message.created": {
+			const clientMessageId = event.clientMessageId;
+			setMessages((currentMessages) => sortMessages(clientMessageId ? replacePendingMessage(currentMessages, clientMessageId, event.message) : mergeMessage(currentMessages, event.message)));
+			return;
+		}
+		case "session.ready":
+			setIsReady(true);
+			return;
+		default: return;
+	}
+}
+function MessageBubble({ message }) {
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("article", {
+		className: "clivly-chat-widget__message",
+		"data-sender": message.senderType,
+		children: [
+			/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+				className: "clivly-chat-widget__message-meta",
+				children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", { children: message.author ?? "Clivly" }), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", { children: formatTimestamp(message.createdAt) })]
+			}),
+			/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", { children: message.body }),
+			message.delivery === "sent" ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+				className: "clivly-chat-widget__status",
+				children: DELIVERY_LABELS[message.delivery]
+			})
+		]
+	});
+}
+/**
+* The scrollable transcript. Split out of `ChatWidget` because the three states
+* (no session, empty thread, messages) were a nested ternary in the render tree
+* — early returns make them readable and keep the parent's complexity down.
+*/
+function MessageList({ greeting, hasSession, messages }) {
+	if (!hasSession) return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+		className: "clivly-chat-widget__empty",
+		children: greeting
+	});
+	if (messages.length === 0) return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+		className: "clivly-chat-widget__empty",
+		children: "No messages yet. Say hello to get the conversation started."
+	});
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(react_jsx_runtime.Fragment, { children: messages.map((message) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)(MessageBubble, { message }, message.id)) });
+}
+function ChatWidget({ className, createTransport, getSession, initiallyOpen = false, launcherLabel = "Chat with us", storage = DEFAULT_STORAGE, style, theme = "auto", widgetId }) {
 	const [isOpen, setIsOpen] = (0, react.useState)(initiallyOpen);
 	const [error, setError] = (0, react.useState)(null);
 	const [isConnecting, setIsConnecting] = (0, react.useState)(false);
@@ -253,7 +497,8 @@ function ChatWidget({ className, createTransport, getSession, initiallyOpen = fa
 	});
 	const transportRef = (0, react.useRef)(null);
 	const listRef = (0, react.useRef)(null);
-	const themeStyle = useThemeStyle(session);
+	const themeStyle = useThemeStyle(session, style);
+	const resolvedTheme = useResolvedTheme(theme);
 	(0, react.useEffect)(() => () => {
 		transportRef.current?.close();
 		transportRef.current = null;
@@ -267,31 +512,6 @@ function ChatWidget({ className, createTransport, getSession, initiallyOpen = fa
 		transportRef.current = null;
 		setIsReady(false);
 		if (!(session && createTransport)) return;
-		const handleEvent = (event) => {
-			switch (event.type) {
-				case "conversation.snapshot":
-					setMessages(sortMessages(event.messages.map((message) => createLocalMessage(message))));
-					return;
-				case "error":
-					setError(event.message);
-					return;
-				case "message.ack":
-					setMessages((currentMessages) => sortMessages(replacePendingMessage(currentMessages, event.clientMessageId, event.message)));
-					return;
-				case "message.created": {
-					const clientMessageId = event.clientMessageId;
-					if (clientMessageId) {
-						setMessages((currentMessages) => sortMessages(replacePendingMessage(currentMessages, clientMessageId, event.message)));
-						return;
-					}
-					setMessages((currentMessages) => sortMessages(mergeMessage(currentMessages, event.message)));
-					return;
-				}
-				case "session.ready":
-					setIsReady(true);
-					return;
-			}
-		};
 		const connection = createTransport({
 			handlers: {
 				onClose: () => {
@@ -300,7 +520,13 @@ function ChatWidget({ className, createTransport, getSession, initiallyOpen = fa
 				onError: (transportError) => {
 					setError(transportError.message);
 				},
-				onEvent: handleEvent,
+				onEvent: (event) => {
+					applyServerEvent(event, {
+						setError,
+						setIsReady,
+						setMessages
+					});
+				},
 				onOpen: () => {
 					setIsReady(true);
 				}
@@ -318,16 +544,18 @@ function ChatWidget({ className, createTransport, getSession, initiallyOpen = fa
 		setError(null);
 		setIsConnecting(true);
 		try {
+			const existingVisitorToken = storage?.getItem(createStorageKey(widgetId)) ?? null;
 			const nextSession = await getSession({
 				visitor,
-				visitorToken: storage?.getItem(createStorageKey(widgetId)) ?? null,
+				visitorToken: existingVisitorToken,
 				widgetId
 			});
 			storage?.setItem(createStorageKey(widgetId), nextSession.visitorToken);
 			setSession(nextSession);
 			setMessages(sortMessages(nextSession.messages.map((message) => createLocalMessage(message))));
 		} catch (sessionError) {
-			setError((sessionError instanceof Error ? sessionError : /* @__PURE__ */ new Error("Failed to start the conversation.")).message);
+			const resolved = sessionError instanceof Error ? sessionError : /* @__PURE__ */ new Error("Failed to start the conversation.");
+			setError(resolved.message);
 		} finally {
 			setIsConnecting(false);
 		}
@@ -342,7 +570,7 @@ function ChatWidget({ className, createTransport, getSession, initiallyOpen = fa
 		if (!body) return;
 		const clientMessageId = generateId();
 		const optimisticMessage = {
-			author: session.contact.name,
+			author: sessionDisplayName(session),
 			body,
 			createdAt: (/* @__PURE__ */ new Date()).toISOString(),
 			id: clientMessageId,
@@ -365,9 +593,10 @@ function ChatWidget({ className, createTransport, getSession, initiallyOpen = fa
 	};
 	const greeting = session?.widget.config.greeting ?? "Tell us a little about yourself and we’ll pick up the conversation from there.";
 	const panelTitle = session?.widget.name ?? "Start a conversation";
-	const sessionSummary = session ? `${session.contact.name} • ${session.contact.email}` : greeting;
+	const sessionSummary = sessionSummaryText(session, greeting);
 	return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
 		className: `clivly-chat-widget ${className ?? ""}`.trim(),
+		"data-clivly-theme": resolvedTheme,
 		style: themeStyle,
 		children: [
 			/* @__PURE__ */ (0, react_jsx_runtime.jsx)("style", { children: WIDGET_STYLES }),
@@ -407,26 +636,10 @@ function ChatWidget({ className, createTransport, getSession, initiallyOpen = fa
 						children: [error ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
 							className: "clivly-chat-widget__error",
 							children: error
-						}) : null, session ? messages.length > 0 ? messages.map((message) => /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("article", {
-							className: "clivly-chat-widget__message",
-							"data-sender": message.senderType,
-							children: [
-								/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
-									className: "clivly-chat-widget__message-meta",
-									children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", { children: message.author ?? "Clivly" }), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", { children: formatTimestamp(message.createdAt) })]
-								}),
-								/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", { children: message.body }),
-								message.delivery === "sent" ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
-									className: "clivly-chat-widget__status",
-									children: message.delivery === "pending" ? "Sending…" : "Failed to send"
-								})
-							]
-						}, message.id)) : /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
-							className: "clivly-chat-widget__empty",
-							children: "No messages yet. Say hello to get the conversation started."
-						}) : /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
-							className: "clivly-chat-widget__empty",
-							children: greeting
+						}) : null, /* @__PURE__ */ (0, react_jsx_runtime.jsx)(MessageList, {
+							greeting,
+							hasSession: Boolean(session),
+							messages
 						})]
 					}),
 					session ? /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("form", {
@@ -617,16 +830,27 @@ const MOUNTED_DATA_ATTR = "clivlyMounted";
 function resolveSocketUrl(socketUrlTemplate, conversationId, token) {
 	return socketUrlTemplate.replaceAll("{conversationId}", encodeURIComponent(conversationId)).replaceAll("{token}", encodeURIComponent(token));
 }
-function mountChatWidget({ container, createTransport, sessionUrl, socketUrlTemplate, widgetId, ...props }) {
+function createWidgetMount({ container, createTransport, sessionUrl, socketUrlTemplate, theme = "auto", widgetId, ...props }) {
 	const transport = createTransport ?? (socketUrlTemplate ? createWebSocketTransport({ resolveUrl: (session) => session.socketUrl ?? resolveSocketUrl(socketUrlTemplate, session.conversation.id, session.token) }) : createClivlyTransport());
+	const getSession = createSessionFetcher({ sessionUrl });
 	const root = (0, react_dom_client.createRoot)(container);
-	root.render(/* @__PURE__ */ (0, react_jsx_runtime.jsx)(ChatWidget, {
-		...props,
-		createTransport: transport,
-		getSession: createSessionFetcher({ sessionUrl }),
-		widgetId
-	}));
-	return root;
+	const render = (nextTheme) => {
+		root.render(/* @__PURE__ */ (0, react_jsx_runtime.jsx)(ChatWidget, {
+			...props,
+			createTransport: transport,
+			getSession,
+			theme: nextTheme,
+			widgetId
+		}));
+	};
+	render(theme);
+	return {
+		root,
+		setTheme: render
+	};
+}
+function mountChatWidget(options) {
+	return createWidgetMount(options).root;
 }
 function markScriptMounted(script) {
 	script.dataset[MOUNTED_DATA_ATTR] = "true";
@@ -645,15 +869,17 @@ function mountChatWidgetScript(script = document.currentScript) {
 	const shadowRoot = host.attachShadow({ mode: "open" });
 	const container = document.createElement("div");
 	shadowRoot.append(container);
-	const root = mountChatWidget({
+	const { root, setTheme } = createWidgetMount({
 		container,
 		sessionUrl,
 		socketUrlTemplate: script.dataset.socketUrlTemplate,
+		theme: parseTheme(script.dataset.theme),
 		widgetId
 	});
 	markScriptMounted(script);
 	return {
 		root,
+		setTheme,
 		shadowRoot
 	};
 }