@smooai/chat-widget 0.5.2 → 0.7.0

package/dist/index.js

@@ -1,4 +1,6 @@
 import { ProtocolError, SmoothAgentClient } from "@smooai/smooth-operator";
+import { createStore } from "zustand/vanilla";
+import { persist } from "zustand/middleware";
 //#region src/config.ts
 /** Resolve a partial config against the built-in defaults. */
 function resolveConfig(config) {
@@ -17,6 +19,7 @@ function resolveConfig(config) {
 		userName: config.userName,
 		userEmail: config.userEmail,
 		userPhone: config.userPhone,
+		authContext: config.authContext,
 		placeholder: config.placeholder ?? "Type a message…",
 		greeting: config.greeting ?? "Hi! How can I help you today?",
 		connectionErrorMessage: config.connectionErrorMessage ?? "We couldn't reach the chat. Please try again in a moment.",
@@ -25,6 +28,9 @@ function resolveConfig(config) {
 		requireName: config.requireName ?? false,
 		requireEmail: config.requireEmail ?? false,
 		requirePhone: config.requirePhone ?? false,
+		collectPhone: config.collectPhone ?? true,
+		collectConsent: config.collectConsent ?? true,
+		allowChatRestore: config.allowChatRestore ?? true,
 		allowAnonymous: config.allowAnonymous ?? false,
 		theme: {
 			text: theme.text ?? "#f8fafc",
@@ -48,6 +54,293 @@ function needsUserInfo(resolved) {
 	return !resolved.allowAnonymous && (resolved.requireName || resolved.requireEmail || resolved.requirePhone);
 }
 //#endregion
+//#region src/fingerprint.ts
+/**
+* Browser fingerprint — a stable, privacy-light identifier used by the
+* smooth-operator server to correlate an anonymous visitor's sessions across
+* page loads (and, server-side, to match an anonymous fingerprint to a known
+* CRM contact). It rides every `create_conversation_session` as
+* `browserFingerprint` (see ADR-048).
+*
+* ## Why not ThumbmarkJS
+*
+* The ADR floats ThumbmarkJS as the reference implementation. For an *embed*
+* that is injected onto arbitrary host pages, ThumbmarkJS is too heavy: its
+* full build pulls in extensive device-detection tables and async
+* component collection, adding tens of kilobytes (and async surface) to a
+* bundle whose whole selling point is staying out of the host page's
+* LCP/TBT budget. The fingerprint here is a few hundred bytes.
+*
+* ## What this is (and the tradeoff)
+*
+* The correlation that actually matters — "is this the same browser as last
+* time?" — is carried by a **persisted random UUID** (the `browserFingerprint`
+* field in the persisted store). That UUID is generated once and reused for
+* the life of the localStorage entry, so same-browser resume is exact and
+* deterministic. The signal hash below is a best-effort entropy *supplement*
+* mixed into that UUID's derivation seed on first generation — it gives the
+* server-side resolver a soft signal for the (rare) cross-storage case where
+* the UUID was cleared but the device is unchanged. It is intentionally NOT a
+* high-entropy device fingerprint: no canvas/WebGL/audio probes, no font
+* enumeration, nothing that reads as invasive tracking. The tradeoff is weaker
+* cross-storage matching in exchange for a tiny, transparent, no-network,
+* XSS-safe implementation. The server's resolver (SMOODEV-2129d) is the source
+* of truth for any fuzzy matching; the client just supplies a stable token.
+*/
+/** Collect a small set of stable, non-invasive browser signals. */
+function collectSignals() {
+	const parts = [];
+	try {
+		const nav = typeof navigator !== "undefined" ? navigator : void 0;
+		if (nav) {
+			parts.push(`ua:${nav.userAgent ?? ""}`);
+			parts.push(`lang:${nav.language ?? ""}`);
+			parts.push(`langs:${Array.isArray(nav.languages) ? nav.languages.join(",") : ""}`);
+			parts.push(`plat:${nav.platform ?? ""}`);
+			parts.push(`hc:${nav.hardwareConcurrency ?? ""}`);
+			parts.push(`dm:${nav.deviceMemory ?? ""}`);
+		}
+		if (typeof screen !== "undefined") parts.push(`scr:${screen.width}x${screen.height}x${screen.colorDepth}`);
+		if (typeof Intl !== "undefined") try {
+			parts.push(`tz:${Intl.DateTimeFormat().resolvedOptions().timeZone ?? ""}`);
+		} catch {}
+		parts.push(`tzo:${(/* @__PURE__ */ new Date()).getTimezoneOffset()}`);
+	} catch {}
+	return parts.join("|");
+}
+/**
+* A small, fast, non-cryptographic string hash (FNV-1a, 32-bit) rendered as
+* an unsigned hex string. Stable across runs for the same input. Not used for
+* any security decision — only to derive a deterministic seed from the signal
+* string above.
+*/
+function fnv1a(input) {
+	let h = 2166136261;
+	for (let i = 0; i < input.length; i++) {
+		h ^= input.charCodeAt(i);
+		h = Math.imul(h, 16777619);
+	}
+	return (h >>> 0).toString(16).padStart(8, "0");
+}
+/** Generate a UUID, preferring `crypto.randomUUID`, falling back to a v4-shaped string. */
+function generateUuid() {
+	try {
+		if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") return crypto.randomUUID();
+	} catch {}
+	return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+		const r = Math.random() * 16 | 0;
+		return (c === "x" ? r : r & 3 | 8).toString(16);
+	});
+}
+/**
+* Compute a fresh fingerprint token: a stable random UUID, suffixed with the
+* FNV hash of the device signals so the server can recover a soft device
+* signal even if it only has the token. Called ONCE per browser (the result is
+* persisted and reused) — see {@link getOrCreateFingerprint}.
+*/
+function computeFingerprint() {
+	const signalHash = fnv1a(collectSignals());
+	return `${generateUuid()}.${signalHash}`;
+}
+/**
+* Return the cached fingerprint if one was already computed for this browser,
+* otherwise compute + persist a new one via the provided accessors. The
+* persistence layer owns storage; this function owns the "compute once" policy.
+*/
+function getOrCreateFingerprint(get, set) {
+	const existing = get();
+	if (existing) return existing;
+	const fp = computeFingerprint();
+	set(fp);
+	return fp;
+}
+//#endregion
+//#region src/persistence.ts
+/**
+* Persisted widget state — the identity / consent / session-pointer client layer
+* (ADR-048, SMOODEV-2129e).
+*
+* Built on Zustand's framework-agnostic `vanilla` store + the `persist`
+* middleware (the user explicitly chose Zustand; it's ~1KB and has no React
+* dependency, so it works inside the web component). The store is keyed per
+* agent — localStorage key `smoo-chat-widget:<agentId>` — so two agents embedded
+* on the same origin don't clobber each other.
+*
+* ## What persists (and, deliberately, what does NOT)
+*
+* Only a **pointer** to the conversation plus the visitor's identity + marketing
+* consent + verified email + browser fingerprint. The transcript is **never**
+* persisted: the smooth-operator server is the source of truth and the widget
+* re-hydrates history via `getMessages` on resume. This keeps localStorage small
+* and avoids stale/divergent transcripts.
+*
+* `version` drives `persist.migrate` so future shape changes can upgrade old
+* blobs in place instead of silently dropping them.
+*/
+/** Current persisted-shape version. Bump when the shape below changes incompatibly. */
+const PERSIST_VERSION = 1;
+const EMPTY_CONSENT = {
+	emailOptIn: false,
+	smsOptIn: false
+};
+function initialPersisted() {
+	return {
+		version: 1,
+		sessionId: null,
+		identity: {},
+		consent: { ...EMPTY_CONSENT },
+		verifiedEmail: null,
+		verifiedEmailSessionId: null,
+		browserFingerprint: null
+	};
+}
+/** localStorage key for an agent's persisted widget state. */
+function storageKey(agentId) {
+	return `smoo-chat-widget:${agentId}`;
+}
+/**
+* An explicit in-memory (Map-backed) `PersistStorage`. Used as the fallback when
+* real localStorage is unavailable.
+*
+* IMPORTANT: we must NOT return `undefined` from {@link safeStorage} in that case.
+* zustand v5's `persist` treats a missing `storage` option by falling back to its
+* OWN `createJSONStorage(() => localStorage)` — i.e. it re-engages the very
+* localStorage the guard was trying to avoid (throwing again in privacy mode).
+* Handing it this no-op storage keeps the store working purely in memory and
+* guarantees the fallback can't touch real localStorage.
+*/
+function memoryStorage() {
+	const mem = /* @__PURE__ */ new Map();
+	return {
+		getItem: (name) => {
+			const raw = mem.get(name);
+			if (!raw) return null;
+			try {
+				return JSON.parse(raw);
+			} catch {
+				return null;
+			}
+		},
+		setItem: (name, value) => {
+			mem.set(name, JSON.stringify(value));
+		},
+		removeItem: (name) => {
+			mem.delete(name);
+		}
+	};
+}
+/**
+* A `persist` storage adapter that tolerates the *absence* of localStorage
+* (SSR, privacy-mode throwing on access, sandboxed iframes). When storage is
+* unavailable the store still works in-memory; nothing is persisted, but the
+* widget never throws on boot.
+*/
+function safeStorage() {
+	let ls = null;
+	try {
+		ls = typeof localStorage !== "undefined" ? localStorage : null;
+		if (ls) {
+			const probe = "__smoo_probe__";
+			ls.setItem(probe, "1");
+			ls.removeItem(probe);
+		}
+	} catch {
+		ls = null;
+	}
+	if (!ls) return memoryStorage();
+	const storage = ls;
+	return {
+		getItem: (name) => {
+			try {
+				const raw = storage.getItem(name);
+				return raw ? JSON.parse(raw) : null;
+			} catch {
+				return null;
+			}
+		},
+		setItem: (name, value) => {
+			try {
+				storage.setItem(name, JSON.stringify(value));
+			} catch {}
+		},
+		removeItem: (name) => {
+			try {
+				storage.removeItem(name);
+			} catch {}
+		}
+	};
+}
+/**
+* Migrate a persisted blob from an older `version` to the current shape. Today
+* v1 is the only version, so this just backfills any missing fields onto an
+* unknown old blob; future versions add `case` branches here.
+*/
+function migrate(persisted) {
+	const base = initialPersisted();
+	if (!persisted || typeof persisted !== "object") return base;
+	const p = persisted;
+	return {
+		version: 1,
+		sessionId: typeof p.sessionId === "string" ? p.sessionId : null,
+		identity: {
+			name: typeof p.identity?.name === "string" ? p.identity.name : void 0,
+			email: typeof p.identity?.email === "string" ? p.identity.email : void 0,
+			phone: typeof p.identity?.phone === "string" ? p.identity.phone : void 0
+		},
+		consent: {
+			emailOptIn: p.consent?.emailOptIn === true,
+			smsOptIn: p.consent?.smsOptIn === true,
+			consentSource: typeof p.consent?.consentSource === "string" ? p.consent.consentSource : void 0,
+			consentAt: typeof p.consent?.consentAt === "string" ? p.consent.consentAt : void 0
+		},
+		verifiedEmail: typeof p.verifiedEmail === "string" ? p.verifiedEmail : null,
+		verifiedEmailSessionId: typeof p.verifiedEmailSessionId === "string" ? p.verifiedEmailSessionId : null,
+		browserFingerprint: typeof p.browserFingerprint === "string" ? p.browserFingerprint : null
+	};
+}
+/**
+* Create the per-agent persisted Zustand store. The `partialize` step ensures
+* only the persisted shape (never any future transient action/UI state) is
+* written to localStorage.
+*/
+function createWidgetStore(agentId) {
+	return createStore()(persist((set) => ({
+		...initialPersisted(),
+		setSessionId: (sessionId) => set({ sessionId }),
+		mergeIdentity: (identity) => set((state) => ({ identity: {
+			...state.identity,
+			...identity.name !== void 0 ? { name: identity.name } : {},
+			...identity.email !== void 0 ? { email: identity.email } : {},
+			...identity.phone !== void 0 ? { phone: identity.phone } : {}
+		} })),
+		setConsent: (consent) => set({ consent: { ...consent } }),
+		setVerifiedEmail: (verifiedEmail, sessionId) => set((state) => ({
+			verifiedEmail,
+			verifiedEmailSessionId: verifiedEmail === null ? null : sessionId ?? state.sessionId
+		})),
+		setBrowserFingerprint: (browserFingerprint) => set({ browserFingerprint }),
+		clearSession: () => set({
+			sessionId: null,
+			verifiedEmail: null,
+			verifiedEmailSessionId: null
+		})
+	}), {
+		name: storageKey(agentId),
+		version: 1,
+		storage: safeStorage(),
+		migrate,
+		partialize: (state) => ({
+			version: 1,
+			sessionId: state.sessionId,
+			identity: state.identity,
+			consent: state.consent,
+			verifiedEmail: state.verifiedEmail,
+			verifiedEmailSessionId: state.verifiedEmailSessionId,
+			browserFingerprint: state.browserFingerprint
+		})
+	}));
+}
+//#endregion
 //#region \0@oxc-project+runtime@0.134.0/helpers/esm/typeof.js
 function _typeof(o) {
 	"@babel/helpers - typeof";
@@ -97,13 +390,41 @@ function _defineProperty(e, r, t) {
 * so the swap is purely at the client-library boundary.
 *
 * Flow:
-*   1. `connect()`        → opens the WebSocket transport and `create_conversation_session`.
+*   1. `connect()`        → opens the WebSocket transport and `create_conversation_session`
+*                           (or RESUMES a persisted session via `get_session`/`get_messages`).
 *   2. `send(text)`       → `send_message`, streaming `stream_token` deltas into the
 *                           in-progress assistant message, then the terminal
 *                           `eventual_response`.
 *
+* 0.7.0 (SMOODEV-2129e) adds the identity / persistence / consent client layer:
+*   - `browserFingerprint` computed once + sent on every `create_conversation_session`.
+*   - identity + marketing consent threaded into the session `metadata`.
+*   - same-session RESUME on load (no engine change — `get_session` + `get_messages`).
+*   - returning-visitor RESUME via `POST /internal/resume-by-fingerprint`, and
+*     cross-device "restore my chats" via the `POST /internal/identity/{request-otp,
+*     verify-otp,resolve}` routes on the chat-ws wrapper. The engine (smooth-operator
+*     1.8.0) owns the `/ws` dispatch and REJECTS unknown verbs, so these are HTTP
+*     `fetch()` calls (origin-allowlisted + optional authContext, per ADR-046/048) —
+*     NOT WS frames.
+*
 * The controller is UI-agnostic: it emits typed events and the view renders them.
 */
+/**
+* Derive the HTTP base for the chat-ws wrapper's `/internal/*` REST routes from
+* the WS endpoint:  `wss://ai.smoo.ai/ws` → `https://ai.smoo.ai`. The engine
+* (smooth-operator 1.8.0) owns the `/ws` dispatch and REJECTS unknown verbs, so
+* the cross-device identity flow + fingerprint resume are HTTP POST routes on the
+* wrapper (origin-allowlisted + authContext, per ADR-046/ADR-048) — NOT WS frames.
+*/
+function httpBaseFromWsEndpoint(endpoint) {
+	try {
+		const u = new URL(endpoint);
+		u.protocol = u.protocol === "ws:" ? "http:" : u.protocol === "wss:" ? "https:" : u.protocol;
+		return `${u.protocol}//${u.host}`;
+	} catch {
+		return null;
+	}
+}
 /** Pull the final assistant text out of an `eventual_response` data payload. */
 function extractFinalText(response) {
 	if (!response || typeof response !== "object") return null;
@@ -144,40 +465,89 @@ function extractCitations(inner) {
 	}
 	return out;
 }
+/** Convert a server message row into a finalized {@link ChatMessage}. */
+function wireMessageToChat(m, idx) {
+	const text = typeof m.content?.text === "string" ? m.content.text : "";
+	if (!text) return null;
+	const role = m.direction === "outbound" ? "assistant" : "user";
+	return {
+		id: typeof m.id === "string" ? m.id : `hist-${idx}`,
+		role,
+		text,
+		streaming: false
+	};
+}
 var ConversationController = class {
-	constructor(config, events) {
+	constructor(config, events, store) {
 		_defineProperty(this, "config", void 0);
 		_defineProperty(this, "events", void 0);
+		_defineProperty(this, "store", void 0);
 		_defineProperty(this, "client", null);
 		_defineProperty(this, "sessionId", null);
 		_defineProperty(this, "messages", []);
 		_defineProperty(this, "status", "idle");
 		_defineProperty(this, "seq", 0);
-		_defineProperty(this, "identity", void 0);
 		_defineProperty(this, "activeRequestId", null);
 		_defineProperty(this, "interrupt", null);
+		_defineProperty(this, "identityRestore", { phase: "idle" });
+		_defineProperty(this, "resumeAttempted", false);
+		_defineProperty(this, "httpBase", void 0);
 		this.config = config;
 		this.events = events;
-		this.identity = {
-			name: config.userName,
-			email: config.userEmail,
-			phone: config.userPhone
-		};
+		this.httpBase = httpBaseFromWsEndpoint(config.endpoint);
+		if (this.httpBase === null) queueMicrotask(() => this.setStatus("error", `Invalid chat endpoint: ${config.endpoint}`));
+		this.store = store ?? createWidgetStore(config.agentId);
+		const seed = {};
+		if (config.userName) seed.name = config.userName;
+		if (config.userEmail) seed.email = config.userEmail;
+		if (config.userPhone) seed.phone = config.userPhone;
+		if (Object.keys(seed).length > 0) this.store.getState().mergeIdentity(seed);
 	}
 	get connectionStatus() {
 		return this.status;
 	}
-	/** Merge in visitor identity (from the pre-chat form). Applied on next connect. */
+	/** The persisted store, exposed so the view can read identity for the pre-chat gate. */
+	getStore() {
+		return this.store;
+	}
+	/** True when a persisted session pointer exists (drives the resume path). */
+	hasPersistedSession() {
+		return !!this.store.getState().sessionId;
+	}
+	/** True when persisted identity exists (lets the view skip the pre-chat form). */
+	hasPersistedIdentity() {
+		const id = this.store.getState().identity;
+		return !!(id.name || id.email || id.phone);
+	}
+	/** Merge in visitor identity + consent (from the pre-chat form). Applied on next connect. */
 	setUserInfo(info) {
-		this.identity = {
-			...this.identity,
-			...info
-		};
+		const { name, email, phone, consent } = info;
+		this.store.getState().mergeIdentity({
+			name,
+			email,
+			phone
+		});
+		if (consent) {
+			const consentAt = consent.emailOptIn || consent.smsOptIn ? (/* @__PURE__ */ new Date()).toISOString() : void 0;
+			this.store.getState().setConsent({
+				emailOptIn: consent.emailOptIn,
+				smsOptIn: consent.smsOptIn,
+				consentSource: "chat-widget-prechat",
+				consentAt
+			});
+		}
 	}
 	setInterrupt(interrupt) {
 		this.interrupt = interrupt;
 		this.events.onInterrupt?.(interrupt);
 	}
+	setIdentityRestore(state) {
+		this.identityRestore = state;
+		this.events.onIdentityRestore?.(state);
+	}
+	get currentIdentityRestore() {
+		return this.identityRestore;
+	}
 	/** Submit an OTP code to resume the paused turn. No-op if not awaiting OTP. */
 	verifyOtp(code) {
 		if (!this.client || !this.sessionId || !this.activeRequestId || this.interrupt?.kind !== "otp") return;
@@ -208,20 +578,95 @@ var ConversationController = class {
 	emitMessages() {
 		this.events.onMessages(this.messages.map((m) => ({ ...m })));
 	}
-	/** Open the transport and create a conversation session. Idempotent. */
+	/** Compute (once) + return the persisted browser fingerprint. */
+	fingerprint() {
+		const state = this.store.getState();
+		return getOrCreateFingerprint(() => state.browserFingerprint, (fp) => this.store.getState().setBrowserFingerprint(fp));
+	}
+	/**
+	* Build the `metadata` payload threaded into `create_conversation_session`:
+	* phone (no first-class engine field) and consent.
+	*
+	* NOTE: `verifiedEmail` is deliberately NOT stamped here. It is a per-session
+	* OTP proof bound to the session it was verified against
+	* (`verifiedEmailSessionId`), and the server only treats an actual OTP `verify`
+	* as proof — metadata `verifiedEmail` is just a hint. Auto-stamping it onto
+	* every brand-new `create_conversation_session` would mislabel a fresh
+	* visitor's session with a prior (possibly different) visitor's email on a
+	* shared browser. The verified email is only used when RESUMING the exact
+	* session it was proven for — see {@link verifiedEmailForSession}.
+	*/
+	sessionMetadata() {
+		const state = this.store.getState();
+		const meta = {};
+		if (state.identity.phone) meta.userPhone = state.identity.phone;
+		const consent = state.consent;
+		if (consent.emailOptIn || consent.smsOptIn || consent.consentAt) {
+			const c = {
+				emailOptIn: consent.emailOptIn,
+				smsOptIn: consent.smsOptIn,
+				consentSource: consent.consentSource ?? "chat-widget-prechat"
+			};
+			if (consent.consentAt) c.consentAt = consent.consentAt;
+			meta.consent = c;
+		}
+		return Object.keys(meta).length > 0 ? meta : void 0;
+	}
+	/**
+	* The verified-email hint, but ONLY when the OTP proof is bound to the session
+	* being resumed (`verifiedEmailSessionId === sessionId`). Returns null
+	* otherwise so a stale/cross-visitor proof is never threaded onto a session it
+	* wasn't proven for.
+	*/
+	verifiedEmailForSession(sessionId) {
+		const state = this.store.getState();
+		if (state.verifiedEmail && state.verifiedEmailSessionId === sessionId) return state.verifiedEmail;
+		return null;
+	}
+	/** Lazily open the WS client (default transport). Idempotent within a connect. */
+	async ensureClient() {
+		if (this.client) return;
+		this.client = new SmoothAgentClient({ url: this.config.endpoint });
+		await this.client.connect();
+	}
+	/**
+	* Open the connection and either RESUME or create a session.
+	*
+	* 1. Persisted pointer (ADR-048 §b): `get_session` → if not `ended`, reuse +
+	*    hydrate from `get_messages` (newest-first, reversed). On ended/404 clear
+	*    ONLY the pointer (identity/consent survive).
+	* 2. No persisted pointer: POST `/internal/resume-by-fingerprint` FIRST; if
+	*    `resumable`, adopt the returned session (the wrapper has primed the
+	*    operator registry), reuse the sessionId, and hydrate via get_session/
+	*    get_messages — rather than relying on createConversationSession to resume.
+	* 3. Otherwise create a fresh session.
+	*/
 	async connect() {
 		if (this.status === "connecting" || this.status === "ready") return;
 		this.setStatus("connecting");
 		try {
-			this.client = new SmoothAgentClient({ url: this.config.endpoint });
-			await this.client.connect();
-			const session = await this.client.createConversationSession({
-				agentId: this.config.agentId,
-				userName: this.identity.name,
-				userEmail: this.identity.email,
-				...this.identity.phone ? { metadata: { userPhone: this.identity.phone } } : {}
-			});
-			this.sessionId = session.sessionId;
+			await this.ensureClient();
+			if (!this.resumeAttempted) {
+				this.resumeAttempted = true;
+				const persistedSessionId = this.store.getState().sessionId;
+				if (persistedSessionId) {
+					if (await this.tryResume(persistedSessionId)) {
+						this.setStatus("ready");
+						return;
+					}
+					this.store.getState().clearSession();
+				} else {
+					const fpSessionId = await this.resumeByFingerprint();
+					if (fpSessionId) {
+						if (await this.tryResume(fpSessionId)) {
+							this.store.getState().setSessionId(fpSessionId);
+							this.setStatus("ready");
+							return;
+						}
+					}
+				}
+			}
+			await this.createSession();
 			this.setStatus("ready");
 		} catch (err) {
 			this.setStatus("error", err instanceof Error ? err.message : String(err));
@@ -229,6 +674,105 @@ var ConversationController = class {
 		}
 	}
 	/**
+	* Build the auth fields every `/internal/*` route shares: `agentId` (required
+	* for the agent-policy lookup), `agentName` (used as the OTP email sender), and
+	* the optional pre-auth `authContext` the host page may have configured. The
+	* `Origin` header is sent automatically by the browser and checked server-side.
+	*/
+	authBody() {
+		const body = { agentId: this.config.agentId };
+		if (this.config.agentName) body.agentName = this.config.agentName;
+		if (this.config.authContext) body.authContext = this.config.authContext;
+		return body;
+	}
+	/** POST JSON to a `/internal/*` route; returns the parsed body (or throws). */
+	async postInternal(path, payload) {
+		if (this.httpBase === null) throw new Error(`Cannot reach ${path}: the chat endpoint is not an absolute URL.`);
+		const res = await fetch(`${this.httpBase}${path}`, {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			credentials: "omit",
+			body: JSON.stringify({
+				...this.authBody(),
+				...payload
+			})
+		});
+		let json = {};
+		try {
+			json = await res.json();
+		} catch {
+			json = {};
+		}
+		if (!res.ok) {
+			const err = json.error;
+			throw new Error(err?.message ?? `${path} failed (${res.status})`);
+		}
+		return json;
+	}
+	/**
+	* POST `/internal/resume-by-fingerprint`. Returns the resumable sessionId when
+	* the wrapper found (and primed) a recent session for this fingerprint, else
+	* null. Network/route failures are swallowed → null (fall through to create).
+	*/
+	async resumeByFingerprint() {
+		try {
+			const json = await this.postInternal("/internal/resume-by-fingerprint", { browserFingerprint: this.fingerprint() });
+			if (json.resumable === true && typeof json.sessionId === "string") return json.sessionId;
+		} catch {}
+		return null;
+	}
+	/** `create_conversation_session` with fingerprint + identity + consent metadata. */
+	async createSession() {
+		if (!this.client) throw new Error("Conversation is not connected");
+		const state = this.store.getState();
+		const metadata = this.sessionMetadata();
+		const session = await this.client.createConversationSession({
+			agentId: this.config.agentId,
+			userName: state.identity.name,
+			userEmail: state.identity.email,
+			browserFingerprint: this.fingerprint(),
+			...metadata ? { metadata } : {}
+		});
+		this.sessionId = session.sessionId;
+		this.store.getState().setSessionId(session.sessionId);
+	}
+	/**
+	* Attempt to resume `sessionId`: returns true and hydrates the transcript when
+	* the session is live, false when it has ended / can't be fetched.
+	*/
+	async tryResume(sessionId) {
+		if (!this.client) return false;
+		let snap;
+		try {
+			snap = await this.client.getSession({ sessionId });
+		} catch {
+			return false;
+		}
+		if (snap.status === "ended") return false;
+		this.sessionId = sessionId;
+		await this.hydrateHistory(sessionId);
+		return true;
+	}
+	/** Page recent history (newest-first), reverse to chronological, and render. */
+	async hydrateHistory(sessionId) {
+		if (!this.client) return;
+		try {
+			const page = await this.client.getMessages({
+				sessionId,
+				limit: 50
+			});
+			const chronological = [...Array.isArray(page.messages) ? page.messages : []].reverse();
+			const hydrated = [];
+			chronological.forEach((m, i) => {
+				const chat = wireMessageToChat(m, i);
+				if (chat) hydrated.push(chat);
+			});
+			this.messages.length = 0;
+			this.messages.push(...hydrated);
+			this.emitMessages();
+		} catch {}
+	}
+	/**
 	* Submit a user message. Appends the user bubble immediately, then streams the
 	* assistant reply token-by-token, finalizing on `eventual_response`.
 	*/
@@ -330,12 +874,170 @@ var ConversationController = class {
 			default: break;
 		}
 	}
+	/**
+	* Begin the cross-device restore: POST `/internal/identity/request-otp` for
+	* `email` over `channel`. The view collects the email via an explicit affordance.
+	*/
+	async requestIdentityOtp(email, channel = "email") {
+		const trimmed = email.trim();
+		if (!trimmed) return;
+		this.setIdentityRestore({
+			phase: "requesting",
+			email: trimmed,
+			channel
+		});
+		if (!this.sessionId) try {
+			await this.connect();
+		} catch {}
+		if (!this.sessionId) {
+			this.setIdentityRestore({
+				phase: "error",
+				message: "No active session to verify against."
+			});
+			return;
+		}
+		try {
+			const json = await this.postInternal("/internal/identity/request-otp", {
+				sessionId: this.sessionId,
+				email: trimmed,
+				channel
+			});
+			const masked = typeof json.maskedDestination === "string" ? json.maskedDestination : void 0;
+			this.setIdentityRestore({
+				phase: "awaiting_code",
+				email: trimmed,
+				channel,
+				maskedDestination: masked
+			});
+		} catch (err) {
+			this.setIdentityRestore({
+				phase: "error",
+				message: err instanceof Error ? err.message : "Could not send a verification code."
+			});
+		}
+	}
+	/** Submit the code: POST `/internal/identity/verify-otp`, then resolve on success. */
+	async verifyIdentityOtp(code) {
+		const state = this.identityRestore;
+		const trimmed = code.trim();
+		if (!trimmed || state.phase !== "awaiting_code") return;
+		const { email, channel } = state;
+		if (!this.sessionId) {
+			this.setIdentityRestore({
+				phase: "error",
+				message: "No active session to verify against."
+			});
+			return;
+		}
+		this.setIdentityRestore({
+			phase: "verifying",
+			email,
+			channel
+		});
+		try {
+			const json = await this.postInternal("/internal/identity/verify-otp", {
+				sessionId: this.sessionId,
+				email,
+				code: trimmed
+			});
+			if (json.event === "otp_verified") {
+				this.store.getState().setVerifiedEmail(email, this.sessionId);
+				await this.resolveIdentity(email);
+			} else if (json.event === "otp_invalid") {
+				const remaining = typeof json.attemptsRemaining === "number" ? json.attemptsRemaining : void 0;
+				this.setIdentityRestore({
+					phase: "awaiting_code",
+					email,
+					channel,
+					error: "That code was incorrect.",
+					attemptsRemaining: remaining
+				});
+			} else this.setIdentityRestore({
+				phase: "error",
+				message: "Verification failed."
+			});
+		} catch (err) {
+			this.setIdentityRestore({
+				phase: "error",
+				message: err instanceof Error ? err.message : "Verification failed."
+			});
+		}
+	}
+	/** Resolve the verified identity → restorable conversations via POST `/internal/identity/resolve`. */
+	async resolveIdentity(email) {
+		if (!this.sessionId) return;
+		this.setIdentityRestore({
+			phase: "resolving",
+			email
+		});
+		try {
+			const json = await this.postInternal("/internal/identity/resolve", {
+				sessionId: this.sessionId,
+				email
+			});
+			if (json.resolved !== true) {
+				this.setIdentityRestore({
+					phase: "resolved",
+					email,
+					conversations: []
+				});
+				return;
+			}
+			const raw = json.conversations;
+			const conversations = Array.isArray(raw) ? raw.map((c) => {
+				if (!c || typeof c !== "object") return null;
+				const o = c;
+				const conversationId = typeof o.conversationId === "string" ? o.conversationId : "";
+				const sessionId = typeof o.sessionId === "string" ? o.sessionId : "";
+				if (!sessionId) return null;
+				return {
+					conversationId,
+					sessionId,
+					lastActivityAt: typeof o.lastActivityAt === "string" ? o.lastActivityAt : void 0,
+					preview: typeof o.preview === "string" ? o.preview : void 0
+				};
+			}).filter((c) => c !== null) : [];
+			this.setIdentityRestore({
+				phase: "resolved",
+				email,
+				conversations
+			});
+		} catch (err) {
+			this.setIdentityRestore({
+				phase: "error",
+				message: err instanceof Error ? err.message : "Could not load your chats."
+			});
+		}
+	}
+	/**
+	* Replay a chosen restorable conversation: point the live session at its
+	* sessionId, hydrate its transcript (get_session + get_messages), and persist
+	* the new pointer so the next `sendMessage` continues it.
+	*/
+	async restoreConversation(sessionId) {
+		if (!this.client) await this.ensureClient();
+		const proven = this.sessionId ? this.verifiedEmailForSession(this.sessionId) : null;
+		if (await this.tryResume(sessionId)) {
+			this.store.getState().setSessionId(sessionId);
+			if (proven) this.store.getState().setVerifiedEmail(proven, sessionId);
+			this.setIdentityRestore({ phase: "idle" });
+			this.setStatus("ready");
+		} else this.setIdentityRestore({
+			phase: "error",
+			message: "That conversation is no longer available."
+		});
+	}
+	/** Dismiss the cross-device restore panel. */
+	cancelIdentityRestore() {
+		this.setIdentityRestore({ phase: "idle" });
+	}
 	/** Tear down the underlying client. */
 	disconnect() {
 		this.client?.disconnect("widget closed");
 		this.client = null;
 		this.sessionId = null;
 		this.activeRequestId = null;
+		this.resumeAttempted = false;
 		this.setInterrupt(null);
 		this.setStatus("closed");
 	}
@@ -351,6 +1053,305 @@ var ConversationController = class {
 */
 const SMOOTH_LOGO_SVG = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<svg id=\"Layer_1\" data-name=\"Layer 1\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" viewBox=\"0 0 550 135\">\n  <defs>\n    <style>\n      .cls-1 {\n        fill: url(#linear-gradient-3);\n      }\n\n      .cls-2 {\n        fill: url(#linear-gradient-2);\n      }\n\n      .cls-3 {\n        fill: url(#linear-gradient);\n        fill-rule: evenodd;\n      }\n    </style>\n    <linearGradient id=\"linear-gradient\" x1=\"115.59\" y1=\"112.81\" x2=\"25.08\" y2=\"22.3\" gradientUnits=\"userSpaceOnUse\">\n      <stop offset=\".3\" stop-color=\"#f49f0a\"/>\n      <stop offset=\".79\" stop-color=\"#fb7a4d\"/>\n      <stop offset=\"1\" stop-color=\"#ff6b6c\"/>\n    </linearGradient>\n    <linearGradient id=\"linear-gradient-2\" x1=\"360.91\" y1=\"152.01\" x2=\"202.32\" y2=\"-6.59\" xlink:href=\"#linear-gradient\"/>\n    <linearGradient id=\"linear-gradient-3\" x1=\"443.91\" y1=\"30.15\" x2=\"531.36\" y2=\"117.59\" gradientUnits=\"userSpaceOnUse\">\n      <stop offset=\".43\" stop-color=\"#00a6a6\"/>\n      <stop offset=\"1\" stop-color=\"#1238dd\"/>\n    </linearGradient>\n  </defs>\n  <path class=\"cls-3\" d=\"M48.28,14.96c-12.39,5.21-22.54,14.64-28.65,26.61-6.12,11.97-7.8,25.72-4.77,38.81,3.04,13.09,10.6,24.69,21.36,32.75,10.76,8.06,24.02,12.05,37.44,11.28,13.42-.77,26.13-6.26,35.9-15.5,9.76-9.24,15.95-21.63,17.46-34.99,1.51-13.36-1.74-26.82-9.19-38.01-1.07-1.61-.64-3.78.97-4.85,1.61-1.07,3.78-.64,4.85.97,8.36,12.56,12.02,27.68,10.32,42.67-1.7,15-8.64,28.91-19.61,39.28-10.96,10.37-25.24,16.54-40.31,17.4-15.07.87-29.96-3.62-42.04-12.66-12.08-9.05-20.58-22.07-23.99-36.77-3.41-14.7-1.51-30.14,5.35-43.58,6.87-13.44,18.26-24.02,32.17-29.87,13.91-5.85,29.44-6.6,43.85-2.11,1.85.57,2.88,2.54,2.3,4.38-.57,1.85-2.54,2.88-4.38,2.3-12.83-4-26.67-3.33-39.06,1.88ZM111.39,19.75c0,2.07-1.68,3.75-3.75,3.75s-3.75-1.68-3.75-3.75,1.68-3.75,3.75-3.75,3.75,1.68,3.75,3.75ZM64.64,59.93c0,1.91,2.39,2.56,7.69,3.88,3.89.97,6.6,2.18,8.15,3.63,1.53,1.45,2.29,3.53,2.29,6.25,0,3.57-1.03,6.26-3.11,8.08-2.07,1.82-5.09,2.73-9.09,2.73h-9.6c-1.97,0-3.57-1.6-3.59-3.57-.01-1.99,1.6-3.61,3.59-3.61h9.41c3.15-.12,4.79-.95,4.91-2.47,0-1.3-1.03-2.21-3.07-2.73-6.91-1.72-11.11-3.44-12.6-5.15-1.48-1.71-2.23-3.77-2.23-6.19,0-6.59,3.2-9.85,9.59-9.8h10.77c1.99,0,3.6,1.61,3.6,3.59s-1.61,3.59-3.6,3.59h-9.69c-1.83,0-3.43.06-3.43,1.77Z\"/>\n  <path class=\"cls-2\" d=\"M205.52,48.44h-8.86c-.44-3.75-2.23-6.65-5.38-8.72-3.16-2.07-7.03-3.1-11.6-3.1h0c-3.35,0-6.27.54-8.78,1.62-2.49,1.09-4.44,2.59-5.84,4.48-1.39,1.89-2.08,4.05-2.08,6.46h0c0,2.01.49,3.75,1.46,5.2.97,1.44,2.22,2.63,3.74,3.58,1.53.95,3.13,1.72,4.8,2.32,1.68.6,3.22,1.09,4.62,1.46h0l7.68,2.06c1.97.52,4.17,1.23,6.6,2.14,2.43.92,4.75,2.16,6.98,3.72,2.23,1.56,4.07,3.56,5.52,6,1.45,2.44,2.18,5.43,2.18,8.98h0c0,4.08-1.07,7.77-3.2,11.08-2.12,3.29-5.22,5.91-9.3,7.86-4.08,1.95-9.02,2.92-14.82,2.92h0c-5.43,0-10.11-.87-14.06-2.62-3.95-1.75-7.05-4.19-9.3-7.32-2.25-3.12-3.53-6.75-3.84-10.88h9.46c.25,2.85,1.22,5.21,2.9,7.06,1.69,1.87,3.83,3.25,6.42,4.14,2.6.89,5.41,1.34,8.42,1.34h0c3.49,0,6.63-.57,9.4-1.72,2.79-1.13,4.99-2.73,6.62-4.8,1.63-2.05,2.44-4.46,2.44-7.22h0c0-2.51-.7-4.55-2.1-6.12-1.41-1.57-3.26-2.85-5.54-3.84-2.29-.99-4.77-1.85-7.44-2.58h0l-9.3-2.66c-5.91-1.71-10.59-4.13-14.04-7.28-3.44-3.16-5.16-7.29-5.16-12.38h0c0-4.23,1.15-7.93,3.46-11.1,2.29-3.16,5.39-5.62,9.3-7.38,3.91-1.76,8.27-2.64,13.08-2.64h0c4.88,0,9.21.87,13,2.6,3.8,1.73,6.81,4.11,9.04,7.12,2.23,3,3.4,6.41,3.52,10.22h0ZM229.16,105.18h-8.72v-56.74h8.42v8.86h.74c1.19-3.03,3.1-5.38,5.74-7.06,2.63-1.69,5.79-2.54,9.48-2.54h0c3.75,0,6.87.85,9.36,2.54,2.51,1.68,4.46,4.03,5.86,7.06h.58c1.45-2.92,3.63-5.25,6.54-7,2.91-1.73,6.39-2.6,10.46-2.6h0c5.07,0,9.21,1.58,12.44,4.74,3.23,3.17,4.84,8.09,4.84,14.76h0v37.98h-8.72v-37.98c0-4.19-1.14-7.18-3.42-8.98-2.29-1.79-4.99-2.68-8.1-2.68h0c-3.99,0-7.07,1.2-9.26,3.6-2.2,2.4-3.3,5.43-3.3,9.1h0v36.94h-8.86v-38.86c0-3.23-1.05-5.83-3.14-7.82-2.09-1.97-4.79-2.96-8.08-2.96h0c-2.27,0-4.38.6-6.34,1.8-1.96,1.21-3.53,2.88-4.72,5-1.2,2.13-1.8,4.59-1.8,7.38h0v35.46ZM333.9,106.36h0c-5.12,0-9.61-1.22-13.46-3.66-3.85-2.44-6.86-5.85-9.02-10.24-2.15-4.37-3.22-9.49-3.22-15.36h0c0-5.91,1.07-11.07,3.22-15.48,2.16-4.4,5.17-7.82,9.02-10.26,3.85-2.44,8.34-3.66,13.46-3.66h0c5.12,0,9.61,1.22,13.46,3.66,3.85,2.44,6.86,5.86,9.02,10.26,2.15,4.41,3.22,9.57,3.22,15.48h0c0,5.87-1.07,10.99-3.22,15.36-2.16,4.39-5.17,7.8-9.02,10.24-3.85,2.44-8.34,3.66-13.46,3.66ZM333.9,98.52h0c3.89,0,7.09-.99,9.6-2.98,2.52-2,4.38-4.63,5.58-7.88,1.21-3.25,1.82-6.77,1.82-10.56h0c0-3.79-.61-7.32-1.82-10.6-1.2-3.27-3.06-5.91-5.58-7.94-2.51-2.01-5.71-3.02-9.6-3.02h0c-3.89,0-7.09,1.01-9.6,3.02-2.51,2.03-4.37,4.67-5.58,7.94-1.2,3.28-1.8,6.81-1.8,10.6h0c0,3.79.6,7.31,1.8,10.56,1.21,3.25,3.07,5.88,5.58,7.88,2.51,1.99,5.71,2.98,9.6,2.98ZM395.94,106.36h0c-5.12,0-9.61-1.22-13.46-3.66-3.85-2.44-6.85-5.85-9-10.24-2.16-4.37-3.24-9.49-3.24-15.36h0c0-5.91,1.08-11.07,3.24-15.48,2.15-4.4,5.15-7.82,9-10.26,3.85-2.44,8.34-3.66,13.46-3.66h0c5.12,0,9.61,1.22,13.46,3.66,3.85,2.44,6.86,5.86,9.02,10.26,2.16,4.41,3.24,9.57,3.24,15.48h0c0,5.87-1.08,10.99-3.24,15.36-2.16,4.39-5.17,7.8-9.02,10.24-3.85,2.44-8.34,3.66-13.46,3.66ZM395.94,98.52h0c3.89,0,7.09-.99,9.6-2.98,2.52-2,4.38-4.63,5.58-7.88,1.21-3.25,1.82-6.77,1.82-10.56h0c0-3.79-.61-7.32-1.82-10.6-1.2-3.27-3.06-5.91-5.58-7.94-2.51-2.01-5.71-3.02-9.6-3.02h0c-3.88,0-7.08,1.01-9.6,3.02-2.51,2.03-4.37,4.67-5.58,7.94-1.2,3.28-1.8,6.81-1.8,10.6h0c0,3.79.6,7.31,1.8,10.56,1.21,3.25,3.07,5.88,5.58,7.88,2.52,1.99,5.72,2.98,9.6,2.98Z\"/>\n  <path class=\"cls-1\" d=\"M467.88,48.02v13.28h-35.79v-13.28h35.79ZM439.68,34.38h17.89v53.42c0,1.5.36,2.62,1.08,3.36.72.74,1.88,1.1,3.49,1.1.62,0,1.48-.07,2.59-.21,1.11-.14,1.91-.27,2.38-.41l2.31,13.02c-2.02.58-3.97.97-5.84,1.18-1.88.21-3.66.31-5.33.31-6.08,0-10.7-1.43-13.84-4.28-3.15-2.85-4.72-7.01-4.72-12.48v-55.01ZM506.59,72.63v32.71h-17.89V28.95h17.53v33.53h-1.13c1.4-4.55,3.6-8.21,6.59-11,2.99-2.79,7.01-4.18,12.07-4.18,4,0,7.48.89,10.46,2.67,2.97,1.78,5.28,4.29,6.92,7.54,1.64,3.25,2.46,7.02,2.46,11.33v36.5h-17.89v-33.02c0-3.21-.82-5.73-2.46-7.56-1.64-1.83-3.93-2.74-6.87-2.74-1.92,0-3.62.42-5.1,1.26-1.49.84-2.64,2.04-3.46,3.61-.82,1.57-1.23,3.49-1.23,5.74Z\"/>\n</svg>";
 //#endregion
+//#region src/markdown.ts
+/**
+* A tiny, safe-by-default Markdown → HTML renderer for the chat widget.
+*
+* ## Why a hand-rolled renderer (and not markdown-it / snarkdown)?
+*
+* The widget renders **untrusted** text in two places: the assistant's reply
+* (LLM output, which can echo attacker-supplied content) and citation snippets
+* (raw scraped page chunks). Today both are written via `textContent`, so
+* `**bold**`, numbered lists, and `[links](url)` show up literally. We want
+* them rendered — without re-opening the XSS hole that `textContent` was
+* guarding against.
+*
+* markdown-it with `html:false` is safe-by-default but ships ~30 kB min into
+* what is an embeddable **global** bundle, where every kilobyte is on the host
+* page's critical path. snarkdown is ~1 kB but emits raw HTML, so it would
+* require bolting on a separate sanitizer. Instead, this renderer is
+* **safe-by-construction**:
+*
+*   1. It is a *tokenizer*, not an HTML passthrough. It only ever emits a
+*      fixed allowlist of tags (`p`, `br`, `strong`, `em`, `ul`/`ol`/`li`,
+*      `code`/`pre`, `a`, `blockquote`). There is no code path that copies a
+*      tag out of the input — a literal `<script>` in the input is treated as
+*      plain text.
+*   2. **Every** text run is HTML-escaped via {@link escapeHtml} before it
+*      reaches the output. Raw `<`, `>`, `&`, `"`, `'` can never become markup.
+*   3. **Images are dropped entirely** — `![alt](src)` renders as its alt text,
+*      no `<img>` is ever produced (a scraped tracking pixel must not load).
+*   4. **Links** are gated through {@link safeHttpUrl}: only absolute `http(s)`
+*      URLs become anchors (with `target="_blank"` + a hardened `rel`);
+*      `javascript:`/`data:`/relative/etc. fall back to plain (escaped) text.
+*   5. **Headings** (`#`..`######`) are *downgraded* to bold lines — a full
+*      `<h1>` is far too large inside a chat bubble or citation card.
+*
+* The output is a string of HTML that is only ever assigned to `innerHTML` of
+* an element the caller controls; because of (1)–(4) it can only contain the
+* allowlisted, attribute-sanitized tags.
+*
+* Supported subset (deliberately small):
+*   - Paragraphs (blank-line separated) and hard/soft line breaks
+*   - `**bold**` / `__bold__`, `*italic*` / `_italic_`
+*   - `` `inline code` `` and fenced ``` ```code blocks``` ```
+*   - `- ` / `* ` / `+ ` unordered lists, `1.` ordered lists
+*   - `> ` blockquotes
+*   - `[text](http(s)://url)` links (images dropped to alt text)
+*   - `#`..`######` headings → bold line
+*/
+/** Escape the five HTML-significant characters so a text run can never be markup. */
+function escapeHtml(value) {
+	return value.replace(/[&<>"']/g, (c) => {
+		switch (c) {
+			case "&": return "&amp;";
+			case "<": return "&lt;";
+			case ">": return "&gt;";
+			case "\"": return "&quot;";
+			default: return "&#39;";
+		}
+	});
+}
+/**
+* Return `url` only if it is a valid absolute `http(s)` URL, else `null`.
+*
+* SECURITY: link targets here originate from untrusted content (LLM output /
+* scraped citation chunks). Allowing an arbitrary string as an `href` permits
+* `javascript:`/`data:`/`vbscript:` URLs that execute on click — a stored-XSS
+* vector. Only absolute http(s) links are rendered as anchors; anything else
+* falls back to plain text upstream.
+*/
+function safeHttpUrl(url) {
+	if (!url) return null;
+	try {
+		const parsed = new URL(url);
+		return parsed.protocol === "http:" || parsed.protocol === "https:" ? parsed.href : null;
+	} catch {
+		return null;
+	}
+}
+/**
+* Render the inline span grammar of a single line/segment to safe HTML.
+*
+* Order matters: code spans are extracted first (their contents are *not*
+* further parsed), then images are stripped to alt text, then links, then
+* emphasis. Every literal text run is escaped on the way out.
+*/
+function renderInline(input) {
+	let out = "";
+	let i = 0;
+	const n = input.length;
+	let buf = "";
+	const flush = () => {
+		if (buf) {
+			out += escapeHtml(buf);
+			buf = "";
+		}
+	};
+	while (i < n) {
+		const ch = input[i];
+		if (ch === "`") {
+			const end = input.indexOf("`", i + 1);
+			if (end > i) {
+				flush();
+				out += `<code>${escapeHtml(input.slice(i + 1, end))}</code>`;
+				i = end + 1;
+				continue;
+			}
+		}
+		if (ch === "!" && input[i + 1] === "[") {
+			const m = imageAt(input, i);
+			if (m) {
+				flush();
+				out += renderInline(m.alt);
+				i = m.end;
+				continue;
+			}
+		}
+		if (ch === "[") {
+			const m = linkAt(input, i);
+			if (m) {
+				flush();
+				const safe = safeHttpUrl(m.href);
+				const inner = renderInline(m.text);
+				if (safe) out += `<a href="${escapeHtml(safe)}" target="_blank" rel="noopener noreferrer nofollow">${inner}</a>`;
+				else out += inner;
+				i = m.end;
+				continue;
+			}
+		}
+		if (ch === "*" && input[i + 1] === "*" || ch === "_" && input[i + 1] === "_") {
+			const marker = ch + ch;
+			const end = input.indexOf(marker, i + 2);
+			if (end > i + 1) {
+				flush();
+				out += `<strong>${renderInline(input.slice(i + 2, end))}</strong>`;
+				i = end + 2;
+				continue;
+			}
+		}
+		if (ch === "*" || ch === "_") {
+			const end = input.indexOf(ch, i + 1);
+			if (end > i + 1 && input[i + 1] !== ch) {
+				flush();
+				out += `<em>${renderInline(input.slice(i + 1, end))}</em>`;
+				i = end + 1;
+				continue;
+			}
+		}
+		buf += ch;
+		i++;
+	}
+	flush();
+	return out;
+}
+/** Parse a `[text](href)` link starting at `start` (`input[start] === '['`). */
+function linkAt(input, start) {
+	const close = matchBracket(input, start);
+	if (close < 0 || input[close + 1] !== "(") return null;
+	const paren = input.indexOf(")", close + 2);
+	if (paren < 0) return null;
+	return {
+		text: input.slice(start + 1, close),
+		href: input.slice(close + 2, paren).trim().split(/\s+/)[0] ?? "",
+		end: paren + 1
+	};
+}
+/** Parse a `![alt](src)` image starting at `start` (`input[start] === '!'`). */
+function imageAt(input, start) {
+	const link = linkAt(input, start + 1);
+	if (!link) return null;
+	return {
+		alt: link.text,
+		end: link.end
+	};
+}
+/** Find the matching `]` for a `[` at `open`, honoring one level of nesting. */
+function matchBracket(input, open) {
+	let depth = 0;
+	for (let i = open; i < input.length; i++) {
+		const c = input[i];
+		if (c === "[") depth++;
+		else if (c === "]") {
+			depth--;
+			if (depth === 0) return i;
+		}
+	}
+	return -1;
+}
+const UL_RE = /^\s*[-*+]\s+(.*)$/;
+const OL_RE = /^\s*\d+[.)]\s+(.*)$/;
+const HEADING_RE = /^\s{0,3}(#{1,6})\s+(.*)$/;
+const QUOTE_RE = /^\s*>\s?(.*)$/;
+const FENCE_RE = /^\s*(`{3,}|~{3,})\s*(.*)$/;
+/**
+* Render a full Markdown string to safe HTML.
+*
+* @returns a string containing only the allowlisted tags described in the
+* module doc. Safe to assign to `innerHTML` of a caller-owned element.
+*/
+function renderMarkdown(src) {
+	const lines = src.replace(/\r\n?/g, "\n").split("\n");
+	const out = [];
+	let i = 0;
+	while (i < lines.length) {
+		const line = lines[i];
+		const fence = FENCE_RE.exec(line);
+		if (fence) {
+			const marker = fence[1];
+			const body = [];
+			i++;
+			while (i < lines.length && !lines[i].trimStart().startsWith(marker)) {
+				body.push(lines[i]);
+				i++;
+			}
+			if (i < lines.length) i++;
+			out.push(`<pre><code>${escapeHtml(body.join("\n"))}</code></pre>`);
+			continue;
+		}
+		if (line.trim() === "") {
+			i++;
+			continue;
+		}
+		const heading = HEADING_RE.exec(line);
+		if (heading) {
+			out.push(`<p><strong>${renderInline(heading[2])}</strong></p>`);
+			i++;
+			continue;
+		}
+		if (UL_RE.test(line) || OL_RE.test(line)) {
+			const ordered = OL_RE.test(line) && !UL_RE.test(line);
+			const re = ordered ? OL_RE : UL_RE;
+			const items = [];
+			while (i < lines.length) {
+				const m = re.exec(lines[i]);
+				if (!m) break;
+				items.push(`<li>${renderInline(m[1])}</li>`);
+				i++;
+			}
+			out.push(`<${ordered ? "ol" : "ul"}>${items.join("")}</${ordered ? "ol" : "ul"}>`);
+			continue;
+		}
+		if (QUOTE_RE.test(line)) {
+			const quoted = [];
+			while (i < lines.length) {
+				const m = QUOTE_RE.exec(lines[i]);
+				if (!m) break;
+				quoted.push(m[1]);
+				i++;
+			}
+			out.push(`<blockquote>${renderInline(quoted.join("\n")).replace(/\n/g, "<br>")}</blockquote>`);
+			continue;
+		}
+		const para = [];
+		while (i < lines.length) {
+			const l = lines[i];
+			if (l.trim() === "" || FENCE_RE.test(l) || HEADING_RE.test(l) || UL_RE.test(l) || OL_RE.test(l) || QUOTE_RE.test(l)) break;
+			para.push(l);
+			i++;
+		}
+		out.push(`<p>${renderInline(para.join("\n")).replace(/\n/g, "<br>")}</p>`);
+	}
+	return out.join("");
+}
+const SNIPPET_MAX = 260;
+/**
+* Clean a raw scraped citation snippet into a short, readable excerpt.
+*
+* Scraped chunks frequently begin with page boilerplate — a logo image wrapped
+* in a link, standalone nav, repeated whitespace — e.g.
+* `[![Logo](…)](…) # Our Work We build…`. The source itself is already linked
+* from the citation card, so the snippet only needs to be a clean teaser.
+*
+* Steps:
+*   1. Strip a leading image / logo-link (`[![…](…)](…)` or `![…](…)`).
+*   2. Drop a leading standalone heading marker (`#`/`##`).
+*   3. Collapse all runs of whitespace to single spaces.
+*   4. Truncate to ~{@link SNIPPET_MAX} chars at a word boundary, adding `…`.
+*
+* The result is still rendered through {@link renderMarkdown} downstream, so any
+* remaining inline markup (bold/links) stays safe.
+*/
+function cleanCitationSnippet(raw) {
+	let s = raw ?? "";
+	let changed = true;
+	while (changed) {
+		changed = false;
+		const before = s;
+		s = s.replace(/^\s*\[!\[[^\]]*\]\([^)]*\)\]\([^)]*\)\s*/, "");
+		s = s.replace(/^\s*!\[[^\]]*\]\([^)]*\)\s*/, "");
+		s = s.replace(/^\s*#{1,6}\s+/, "");
+		if (s !== before) changed = true;
+	}
+	s = s.replace(/\s+/g, " ").trim();
+	if (s.length > SNIPPET_MAX) {
+		const cut = s.slice(0, SNIPPET_MAX);
+		const lastSpace = cut.lastIndexOf(" ");
+		s = (lastSpace > SNIPPET_MAX * .6 ? cut.slice(0, lastSpace) : cut).trimEnd() + "…";
+	}
+	return s;
+}
+//#endregion
 //#region src/styles.ts
 /**
 * Render the widget's scoped stylesheet — the "Aurora Glass" design system.
@@ -675,6 +1676,50 @@ function buildStyles(theme, mode = "popover") {
 }
 @keyframes sac-blink { to { opacity: 0 } }
 
+/* ─────────────── Rendered markdown (assistant bubbles / snippets) ─────────── */
+/* The renderer (markdown.ts) emits a small allowlisted set of tags; these rules
+   keep them legible inside the tight Aurora-Glass bubble + citation card. */
+/* Block-level markdown drives its own spacing/wrapping, so opt out of the
+   bubble's pre-wrap (which would otherwise add stray blank lines). */
+.bubble.md { white-space: normal; }
+.md > :first-child { margin-top: 0; }
+.md > :last-child { margin-bottom: 0; }
+.md p { margin: 0 0 8px; }
+.md ul, .md ol { margin: 6px 0 8px; padding-left: 20px; }
+.md li { margin: 2px 0; }
+.md li::marker { color: color-mix(in srgb, var(--sac-primary) 75%, transparent); }
+.md a {
+    color: color-mix(in srgb, var(--sac-primary) 92%, #fff);
+    text-decoration: underline;
+    text-underline-offset: 2px;
+    word-break: break-word;
+}
+.md a:hover { text-decoration: none; }
+.md strong { font-weight: 700; }
+.md em { font-style: italic; }
+.md code {
+    font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+    font-size: .9em;
+    padding: 1px 5px;
+    border-radius: 5px;
+    background: color-mix(in srgb, var(--sac-text) 10%, transparent);
+}
+.md pre {
+    margin: 6px 0 8px;
+    padding: 9px 11px;
+    border-radius: 9px;
+    overflow-x: auto;
+    background: color-mix(in srgb, var(--sac-text) 9%, transparent);
+    border: 1px solid color-mix(in srgb, var(--sac-text) 8%, transparent);
+}
+.md pre code { padding: 0; background: none; font-size: 12px; line-height: 1.45; }
+.md blockquote {
+    margin: 6px 0;
+    padding: 2px 0 2px 11px;
+    border-left: 2px solid color-mix(in srgb, var(--sac-primary) 55%, transparent);
+    color: color-mix(in srgb, var(--sac-text) 78%, transparent);
+}
+
 /* Full-page: center the conversation in a readable column. */
 .panel.fullpage .messages { padding: 26px 20px; }
 .panel.fullpage .row { max-width: 760px; width: 100%; margin-left: auto; margin-right: auto; }
@@ -834,6 +1879,17 @@ function buildStyles(theme, mode = "popover") {
 }
 .pc-submit:hover { transform: translateY(-1px); }
 .pc-submit:active { transform: scale(.98); }
+.pc-consents { display: flex; flex-direction: column; gap: 9px; margin-top: 2px; }
+.pc-consent { display: flex; align-items: flex-start; gap: 9px; cursor: pointer; }
+.pc-consent input {
+    margin-top: 2px;
+    width: 16px;
+    height: 16px;
+    flex: 0 0 auto;
+    accent-color: var(--sac-primary);
+    cursor: pointer;
+}
+.pc-consent span { font-size: 12px; line-height: 1.4; color: color-mix(in srgb, var(--sac-text) 72%, transparent); }
 
 /* ─────────────────── Starter-prompt chips ─────────────────────────── */
 .prompts { display: flex; flex-wrap: wrap; gap: 8px; margin: 2px 0 2px 35px; }
@@ -912,6 +1968,61 @@ function buildStyles(theme, mode = "popover") {
 .int-row .int-btn { flex: 1; }
 .int-row .int-input + .int-btn { flex: 0 0 auto; }
 .int-error { margin-top: 8px; font-size: 12px; color: #f87171; }
+.int-card { position: relative; }
+.int-close {
+    position: absolute;
+    top: 8px;
+    right: 9px;
+    border: none;
+    background: transparent;
+    color: color-mix(in srgb, var(--sac-text) 55%, transparent);
+    font-size: 18px;
+    line-height: 1;
+    cursor: pointer;
+    padding: 2px 4px;
+    border-radius: 6px;
+    transition: color .2s ease, background .2s ease;
+}
+.int-close:hover { color: var(--sac-text); background: color-mix(in srgb, var(--sac-text) 8%, transparent); }
+
+/* ─────────────── Cross-device "Restore my chats" ──────────────────── */
+.restore-link {
+    border: none;
+    background: none;
+    padding: 0;
+    font: inherit;
+    font-size: 10.5px;
+    letter-spacing: .04em;
+    color: color-mix(in srgb, var(--sac-primary) 80%, var(--sac-text));
+    cursor: pointer;
+    text-decoration: underline;
+    text-underline-offset: 2px;
+}
+.restore-link:hover { color: var(--sac-primary); }
+.restore-list { display: flex; flex-direction: column; gap: 7px; margin-top: 9px; }
+.restore-item {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 10px;
+    text-align: left;
+    border: 1px solid color-mix(in srgb, var(--sac-border) 80%, transparent);
+    background: var(--sac-bg);
+    color: var(--sac-text);
+    border-radius: 10px;
+    padding: 9px 11px;
+    font-family: inherit;
+    font-size: 12.5px;
+    cursor: pointer;
+    transition: border-color .2s ease, background .2s ease, transform .2s ease;
+}
+.restore-item:hover {
+    border-color: color-mix(in srgb, var(--sac-primary) 50%, transparent);
+    background: color-mix(in srgb, var(--sac-primary) 8%, var(--sac-bg));
+    transform: translateY(-1px);
+}
+.restore-preview { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.restore-when { flex: 0 0 auto; font-size: 11px; color: color-mix(in srgb, var(--sac-text) 55%, transparent); }
 
 .hidden { display: none !important; }
 
@@ -953,24 +2064,6 @@ const ICON = {
 	/** Tool-confirmation interrupt — a shield. */
 	shield: `<svg viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg"><path d="M12 3 5 6v5c0 4.4 3 7.2 7 8.5 4-1.3 7-4.1 7-8.5V6l-7-3Z" stroke="currentColor" stroke-width="1.7" stroke-linejoin="round"/><path d="m9 11.5 2 2 4-4" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round"/></svg>`
 };
-/**
-* Return `url` only if it is a valid absolute `http(s)` URL, else `null`.
-*
-* SECURITY: citation URLs originate from indexed content (web / GitHub
-* connectors), which can be attacker-influenceable. Assigning an arbitrary
-* string to `<a>.href` allows `javascript:`/`data:`/`vbscript:` URLs that
-* execute on click — a stored-XSS vector. Only http(s) links are rendered as
-* anchors; anything else falls back to plain text.
-*/
-function safeHttpUrl(url) {
-	if (!url) return null;
-	try {
-		const parsed = new URL(url);
-		return parsed.protocol === "http:" || parsed.protocol === "https:" ? parsed.href : null;
-	} catch {
-		return null;
-	}
-}
 var SmoothAgentChatElement = class extends HTMLElement {
 	static get observedAttributes() {
 		return OBSERVED;
@@ -987,8 +2080,12 @@ var SmoothAgentChatElement = class extends HTMLElement {
 		_defineProperty(this, "userInfoSatisfied", false);
 		_defineProperty(this, "hasSent", false);
 		_defineProperty(this, "examplePrompts", []);
+		_defineProperty(this, "greeting", "");
 		_defineProperty(this, "interrupt", null);
 		_defineProperty(this, "interruptEl", null);
+		_defineProperty(this, "identityRestore", { phase: "idle" });
+		_defineProperty(this, "allowChatRestore", true);
+		_defineProperty(this, "gating", false);
 		_defineProperty(this, "panelEl", null);
 		_defineProperty(this, "launcherEl", null);
 		_defineProperty(this, "messagesEl", null);
@@ -996,6 +2093,11 @@ var SmoothAgentChatElement = class extends HTMLElement {
 		_defineProperty(this, "dotEl", null);
 		_defineProperty(this, "inputEl", null);
 		_defineProperty(this, "sendBtn", null);
+		_defineProperty(this, "streamBubbleEl", null);
+		_defineProperty(this, "streamMsgId", null);
+		_defineProperty(this, "streamTarget", "");
+		_defineProperty(this, "displayedLength", 0);
+		_defineProperty(this, "rafId", 0);
 		this.root = this.attachShadow({ mode: "open" });
 	}
 	connectedCallback() {
@@ -1004,6 +2106,7 @@ var SmoothAgentChatElement = class extends HTMLElement {
 	}
 	disconnectedCallback() {
 		this.mounted = false;
+		this.resetReveal();
 		this.controller?.disconnect();
 		this.controller = null;
 	}
@@ -1029,7 +2132,7 @@ var SmoothAgentChatElement = class extends HTMLElement {
 	openChat() {
 		this.open = true;
 		this.syncOpenState();
-		this.controller?.connect().catch(() => {});
+		if (!this.gating) this.controller?.connect().catch(() => {});
 	}
 	/** Collapse the chat panel back to the launcher. */
 	closeChat() {
@@ -1050,6 +2153,7 @@ var SmoothAgentChatElement = class extends HTMLElement {
 			userName: this.overrides.userName,
 			userEmail: this.overrides.userEmail,
 			userPhone: this.overrides.userPhone,
+			authContext: this.overrides.authContext,
 			placeholder: this.overrides.placeholder ?? this.getAttribute("placeholder") ?? void 0,
 			greeting: this.overrides.greeting ?? this.getAttribute("greeting") ?? void 0,
 			connectionErrorMessage: this.overrides.connectionErrorMessage,
@@ -1058,6 +2162,9 @@ var SmoothAgentChatElement = class extends HTMLElement {
 			requireName: this.overrides.requireName,
 			requireEmail: this.overrides.requireEmail,
 			requirePhone: this.overrides.requirePhone,
+			collectPhone: this.overrides.collectPhone,
+			collectConsent: this.overrides.collectConsent,
+			allowChatRestore: this.overrides.allowChatRestore,
 			allowAnonymous: this.overrides.allowAnonymous,
 			theme
 		};
@@ -1069,11 +2176,11 @@ var SmoothAgentChatElement = class extends HTMLElement {
 			return;
 		}
 		const resolved = resolveConfig(config);
+		this.allowChatRestore = resolved.allowChatRestore;
 		if (!this.controller) {
 			this.controller = new ConversationController(config, {
 				onMessages: (messages) => {
-					this.messages = messages;
-					this.renderMessages(resolved.greeting);
+					this.handleMessages(messages, resolved.greeting);
 				},
 				onStatus: (status) => {
 					this.status = status;
@@ -1083,9 +2190,14 @@ var SmoothAgentChatElement = class extends HTMLElement {
 				onInterrupt: (interrupt) => {
 					this.interrupt = interrupt;
 					this.renderInterrupt();
+				},
+				onIdentityRestore: (state) => {
+					this.identityRestore = state;
+					this.renderInterrupt();
 				}
 			});
 			if (resolved.startOpen) this.open = true;
+			if (this.controller.hasPersistedSession() || this.controller.hasPersistedIdentity()) this.userInfoSatisfied = true;
 		}
 		const fullpage = resolved.mode === "fullpage";
 		if (fullpage) this.open = true;
@@ -1108,8 +2220,16 @@ var SmoothAgentChatElement = class extends HTMLElement {
                     <button class="close" aria-label="Close chat">${ICON.close}</button>
                 </div>`;
 		this.examplePrompts = resolved.examplePrompts;
+		this.greeting = resolved.greeting;
 		const gating = needsUserInfo(resolved) && !this.userInfoSatisfied;
-		const field = (name, type, label, autocomplete) => `<label class="pc-field"><span>${escapeHtml(label)}</span><input name="${name}" type="${type}" autocomplete="${autocomplete}" required /></label>`;
+		this.gating = gating;
+		const showPhone = resolved.requirePhone || resolved.collectPhone;
+		const field = (name, type, label, autocomplete, required) => `<label class="pc-field"><span>${escapeHtml(label)}</span><input name="${name}" type="${type}" autocomplete="${autocomplete}"${required ? " required" : ""} /></label>`;
+		const consentBox = (name, label) => `<label class="pc-consent"><input name="${name}" type="checkbox" /><span>${escapeHtml(label)}</span></label>`;
+		const consentHtml = resolved.collectConsent ? `<div class="pc-consents">
+                    ${consentBox("emailOptIn", "Email me product news and offers.")}
+                    ${consentBox("smsOptIn", "Text me updates by SMS. Message/data rates may apply.")}
+                </div>` : "";
 		const prechatHtml = `
             <div class="prechat">
                 <div class="pc-head">
@@ -1117,12 +2237,14 @@ var SmoothAgentChatElement = class extends HTMLElement {
                     <div class="pc-sub">A couple details so ${escapeHtml(resolved.agentName)} can help.</div>
                 </div>
                 <form class="pc-form" novalidate>
-                    ${resolved.requireName ? field("name", "text", "Name", "name") : ""}
-                    ${resolved.requireEmail ? field("email", "email", "Email", "email") : ""}
-                    ${resolved.requirePhone ? field("phone", "tel", "Phone", "tel") : ""}
+                    ${resolved.requireName ? field("name", "text", "Name", "name", true) : ""}
+                    ${resolved.requireEmail ? field("email", "email", "Email", "email", true) : ""}
+                    ${showPhone ? field("phone", "tel", "Phone", "tel", resolved.requirePhone) : ""}
+                    ${consentHtml}
                     <button type="submit" class="pc-submit">Start chat</button>
                 </form>
             </div>`;
+		const restoreLink = this.allowChatRestore ? ` · <button type="button" class="restore-link">Restore my chats</button>` : "";
 		const chatHtml = `
                 <div class="messages"></div>
                 <div class="interrupt hidden"></div>
@@ -1131,7 +2253,7 @@ var SmoothAgentChatElement = class extends HTMLElement {
                         <textarea rows="1" placeholder="${escapeHtml(resolved.placeholder)}"></textarea>
                         <button class="send" type="button" aria-label="Send message">${ICON.send}</button>
                     </div>
-                    <div class="footer">powered by <b>smooth&#8209;operator</b></div>
+                    <div class="footer">powered by <b>smooth&#8209;operator</b>${restoreLink}</div>
                 </div>`;
 		const container = document.createElement("div");
 		container.innerHTML = `
@@ -1144,6 +2266,7 @@ var SmoothAgentChatElement = class extends HTMLElement {
         `;
 		const logoSvg = container.querySelector(".logo-wrap svg");
 		if (logoSvg) logoSvg.setAttribute("class", "logo");
+		this.resetReveal();
 		this.root.replaceChildren(style, container);
 		this.launcherEl = container.querySelector(".launcher");
 		this.panelEl = container.querySelector(".panel");
@@ -1168,9 +2291,16 @@ var SmoothAgentChatElement = class extends HTMLElement {
 			ev.preventDefault();
 			this.handlePrechatSubmit(pcForm);
 		});
+		container.querySelector(".restore-link")?.addEventListener("click", () => {
+			(async () => {
+				this.identityRestore = { phase: "awaiting_email" };
+				this.renderInterrupt();
+				await this.controller?.connect().catch(() => {});
+			})();
+		});
 		if (fullpage && !gating) this.controller?.connect().catch(() => {});
 		this.syncOpenState();
-		if (!gating) this.renderMessages(resolved.greeting);
+		if (!gating) this.renderMessages();
 		this.renderStatus();
 		this.renderComposerState();
 		this.renderInterrupt();
@@ -1186,6 +2316,11 @@ var SmoothAgentChatElement = class extends HTMLElement {
 		el.replaceChildren();
 		const it = this.interrupt;
 		if (!it) {
+			if (this.identityRestore.phase !== "idle") {
+				el.classList.remove("hidden");
+				el.appendChild(this.buildRestoreCard());
+				return;
+			}
 			el.classList.add("hidden");
 			return;
 		}
@@ -1265,15 +2400,186 @@ var SmoothAgentChatElement = class extends HTMLElement {
 		}
 		el.appendChild(card);
 	}
-	/** Collect identity from the pre-chat form, then drop into the chat view. */
+	/**
+	* Build the cross-device "Restore my chats" card (ADR-048 §c). Reuses the
+	* same overlay slot + visual language as the OTP interrupt. All server-supplied
+	* strings (masked destination, conversation previews) are set via `textContent`
+	* — never innerHTML — so they can't inject markup; only the static lock icon
+	* uses innerHTML.
+	*/
+	buildRestoreCard() {
+		const state = this.identityRestore;
+		const card = document.createElement("div");
+		card.className = "int-card";
+		const head = document.createElement("div");
+		head.className = "int-head";
+		const ico = document.createElement("span");
+		ico.className = "int-ico";
+		ico.innerHTML = ICON.lock;
+		const title = document.createElement("span");
+		title.className = "int-title";
+		title.textContent = "Restore your chats";
+		head.append(ico, title);
+		card.appendChild(head);
+		const close = document.createElement("button");
+		close.className = "int-close";
+		close.type = "button";
+		close.setAttribute("aria-label", "Cancel");
+		close.textContent = "×";
+		close.addEventListener("click", () => {
+			this.controller?.cancelIdentityRestore();
+			this.identityRestore = { phase: "idle" };
+			this.renderInterrupt();
+		});
+		card.appendChild(close);
+		if (state.phase === "awaiting_email") {
+			const desc = document.createElement("div");
+			desc.className = "int-desc";
+			desc.textContent = "Enter your email and we'll send a code to find your previous chats.";
+			card.appendChild(desc);
+			const row = document.createElement("div");
+			row.className = "int-row";
+			const input = document.createElement("input");
+			input.className = "int-input";
+			input.type = "email";
+			input.autocomplete = "email";
+			input.placeholder = "you@example.com";
+			const go = () => {
+				const email = input.value.trim();
+				if (email) this.controller?.requestIdentityOtp(email, "email");
+			};
+			input.addEventListener("keydown", (ev) => {
+				if (ev.key === "Enter") {
+					ev.preventDefault();
+					go();
+				}
+			});
+			const send = document.createElement("button");
+			send.className = "int-btn primary";
+			send.type = "button";
+			send.textContent = "Send code";
+			send.addEventListener("click", go);
+			row.append(input, send);
+			card.appendChild(row);
+			if (state.error) {
+				const err = document.createElement("div");
+				err.className = "int-error";
+				err.textContent = state.error;
+				card.appendChild(err);
+			}
+			queueMicrotask(() => input.focus());
+		} else if (state.phase === "requesting" || state.phase === "verifying" || state.phase === "resolving") {
+			const msg = document.createElement("div");
+			msg.className = "int-sent";
+			msg.textContent = state.phase === "requesting" ? "Sending a code…" : state.phase === "verifying" ? "Verifying…" : "Finding your chats…";
+			card.appendChild(msg);
+		} else if (state.phase === "awaiting_code") {
+			if (state.maskedDestination) {
+				const sent = document.createElement("div");
+				sent.className = "int-sent";
+				sent.textContent = `Code sent to ${state.maskedDestination}.`;
+				card.appendChild(sent);
+			}
+			const row = document.createElement("div");
+			row.className = "int-row";
+			const input = document.createElement("input");
+			input.className = "int-input";
+			input.type = "text";
+			input.inputMode = "numeric";
+			input.autocomplete = "one-time-code";
+			input.placeholder = "Enter code";
+			const submit = () => {
+				const code = input.value.trim();
+				if (code) this.controller?.verifyIdentityOtp(code);
+			};
+			input.addEventListener("keydown", (ev) => {
+				if (ev.key === "Enter") {
+					ev.preventDefault();
+					submit();
+				}
+			});
+			const verify = document.createElement("button");
+			verify.className = "int-btn primary";
+			verify.type = "button";
+			verify.textContent = "Verify";
+			verify.addEventListener("click", submit);
+			row.append(input, verify);
+			card.appendChild(row);
+			if (state.error) {
+				const err = document.createElement("div");
+				err.className = "int-error";
+				err.textContent = state.attemptsRemaining != null ? `${state.error} (${state.attemptsRemaining} left)` : state.error;
+				card.appendChild(err);
+			}
+			queueMicrotask(() => input.focus());
+		} else if (state.phase === "resolved") if (state.conversations.length === 0) {
+			const none = document.createElement("div");
+			none.className = "int-desc";
+			none.textContent = "No previous chats found for that email.";
+			card.appendChild(none);
+		} else {
+			const pick = document.createElement("div");
+			pick.className = "int-desc";
+			pick.textContent = "Pick a conversation to continue:";
+			card.appendChild(pick);
+			const list = document.createElement("div");
+			list.className = "restore-list";
+			for (const conv of state.conversations) {
+				const btn = document.createElement("button");
+				btn.type = "button";
+				btn.className = "restore-item";
+				const preview = document.createElement("span");
+				preview.className = "restore-preview";
+				preview.textContent = conv.preview || "Conversation";
+				btn.appendChild(preview);
+				if (conv.lastActivityAt) {
+					const when = document.createElement("span");
+					when.className = "restore-when";
+					when.textContent = this.formatWhen(conv.lastActivityAt);
+					btn.appendChild(when);
+				}
+				btn.addEventListener("click", () => {
+					this.controller?.restoreConversation(conv.sessionId);
+				});
+				list.appendChild(btn);
+			}
+			card.appendChild(list);
+		}
+		else if (state.phase === "error") {
+			const err = document.createElement("div");
+			err.className = "int-error";
+			err.textContent = state.message;
+			card.appendChild(err);
+		}
+		return card;
+	}
+	/** Format an ISO timestamp as a short, locale-aware label (best-effort). */
+	formatWhen(iso) {
+		const d = new Date(iso);
+		if (Number.isNaN(d.getTime())) return "";
+		try {
+			return d.toLocaleDateString(void 0, {
+				month: "short",
+				day: "numeric"
+			});
+		} catch {
+			return "";
+		}
+	}
+	/** Collect identity + consent from the pre-chat form, then drop into the chat view. */
 	handlePrechatSubmit(form) {
 		if (!form.reportValidity()) return;
 		const data = new FormData(form);
 		const val = (k) => data.get(k)?.trim() || void 0;
+		const checked = (k) => data.get(k) === "on";
 		this.controller?.setUserInfo({
 			name: val("name"),
 			email: val("email"),
-			phone: val("phone")
+			phone: val("phone"),
+			consent: {
+				emailOptIn: checked("emailOptIn"),
+				smsOptIn: checked("smsOptIn")
+			}
 		});
 		this.userInfoSatisfied = true;
 		this.render();
@@ -1301,9 +2607,35 @@ var SmoothAgentChatElement = class extends HTMLElement {
 		ta.style.height = "auto";
 		ta.style.height = `${ta.scrollHeight}px`;
 	}
-	renderMessages(greeting) {
+	/**
+	* Receive a new message snapshot from the controller and update the view.
+	*
+	* `onMessages` fires on *every* `stream_token` delta. Rebuilding the whole
+	* list each frame is wasteful and fights the smooth reveal, so we take the
+	* cheap path when the only change is the trailing streaming assistant message
+	* growing: just bump the reveal *target* (the rAF loop drains it). Any
+	* structural change (new message, finalize, citations) triggers a full
+	* rebuild via {@link renderMessages}.
+	*/
+	handleMessages(messages, greeting) {
+		this.greeting = greeting;
+		const prev = this.messages;
+		const last = messages[messages.length - 1];
+		const prevLast = prev[prev.length - 1];
+		const structural = messages.length !== prev.length || !last || !prevLast || last.id !== prevLast.id || last.role !== prevLast.role || last.streaming !== prevLast.streaming || !!last.streaming && !prevLast.text && !!last.text;
+		this.messages = messages;
+		if (!structural && last && last.streaming && last.id === this.streamMsgId) {
+			this.streamTarget = last.text;
+			this.ensureRevealLoop();
+			return;
+		}
+		this.renderMessages();
+	}
+	renderMessages() {
 		if (!this.messagesEl) return;
+		this.resetReveal();
 		this.messagesEl.replaceChildren();
+		const greeting = this.greeting;
 		if (this.messages.length === 0 && greeting) this.messagesEl.appendChild(this.buildRow("assistant", this.greetingBubble(greeting)));
 		if (!this.hasSent && this.messages.length === 0 && this.examplePrompts.length > 0) {
 			const chips = document.createElement("div");
@@ -1326,12 +2658,94 @@ var SmoothAgentChatElement = class extends HTMLElement {
 				bubble.append(this.typingDot(), this.typingDot(), this.typingDot());
 			} else if (msg.streaming) {
 				bubble.classList.add("cursor");
-				bubble.textContent = msg.text;
+				this.bindReveal(msg, bubble);
+			} else if (msg.role === "assistant") {
+				bubble.classList.add("md");
+				bubble.innerHTML = renderMarkdown(msg.text);
 			} else bubble.textContent = msg.text;
 			this.messagesEl.appendChild(this.buildRow(msg.role, bubble));
 			if (msg.role === "assistant" && !msg.streaming && msg.citations && msg.citations.length > 0) this.messagesEl.appendChild(this.renderSources(msg.citations));
 		}
-		this.messagesEl.scrollTop = this.messagesEl.scrollHeight;
+		this.scrollToBottom(true);
+	}
+	/** True when the host/user prefers reduced motion (snap, no typewriter). */
+	prefersReducedMotion() {
+		return typeof matchMedia === "function" && matchMedia("(prefers-reduced-motion: reduce)").matches;
+	}
+	/**
+	* Bind the rAF typewriter to a freshly built streaming bubble. Preserves the
+	* already-revealed prefix across rebuilds (so a structural rebuild mid-stream
+	* doesn't restart the reveal from zero), then resumes the loop.
+	*/
+	bindReveal(msg, bubble) {
+		const carryOver = msg.id === this.streamMsgId ? Math.min(this.displayedLength, msg.text.length) : 0;
+		this.streamBubbleEl = bubble;
+		this.streamMsgId = msg.id;
+		this.streamTarget = msg.text;
+		this.displayedLength = carryOver;
+		if (this.prefersReducedMotion()) {
+			this.displayedLength = msg.text.length;
+			bubble.textContent = msg.text;
+			return;
+		}
+		bubble.textContent = msg.text.slice(0, this.displayedLength);
+		this.ensureRevealLoop();
+	}
+	/** Start the rAF loop if it isn't already running. */
+	ensureRevealLoop() {
+		if (this.prefersReducedMotion() || typeof requestAnimationFrame !== "function") {
+			this.snapReveal();
+			return;
+		}
+		if (this.rafId) return;
+		this.rafId = requestAnimationFrame(() => this.tickReveal());
+	}
+	/**
+	* One animation frame of the reveal. Advances `displayedLength` toward the
+	* buffered target at an ADAPTIVE rate — the deeper the backlog, the more
+	* chars per frame — so the reveal stays smooth yet never falls behind the
+	* network. Updates ONLY the bound bubble's textContent (no list rebuild).
+	*/
+	tickReveal() {
+		this.rafId = 0;
+		const bubble = this.streamBubbleEl;
+		if (!bubble) return;
+		const target = this.streamTarget;
+		const remaining = target.length - this.displayedLength;
+		if (remaining <= 0) return;
+		const step = Math.max(2, Math.min(remaining, Math.ceil(remaining / 8)));
+		this.displayedLength = Math.min(target.length, this.displayedLength + step);
+		bubble.textContent = target.slice(0, this.displayedLength);
+		this.scrollToBottom(false);
+		this.rafId = requestAnimationFrame(() => this.tickReveal());
+	}
+	/** Snap the bound bubble to the full buffered text immediately (reduced-motion / no-rAF). */
+	snapReveal() {
+		if (this.streamBubbleEl) {
+			this.displayedLength = this.streamTarget.length;
+			this.streamBubbleEl.textContent = this.streamTarget;
+		}
+	}
+	/** Cancel any in-flight reveal loop and clear its state (called on full rebuild). */
+	resetReveal() {
+		if (this.rafId && typeof cancelAnimationFrame === "function") cancelAnimationFrame(this.rafId);
+		this.rafId = 0;
+		this.streamBubbleEl = null;
+	}
+	/**
+	* Auto-scroll the message list to the bottom — but don't fight a visitor who
+	* has scrolled up to read history. When `force` (a structural rebuild) we
+	* always pin to bottom; during the streaming reveal we only follow if the
+	* viewport is already near the bottom.
+	*/
+	scrollToBottom(force) {
+		const el = this.messagesEl;
+		if (!el) return;
+		if (force) {
+			el.scrollTop = el.scrollHeight;
+			return;
+		}
+		if (el.scrollHeight - el.scrollTop - el.clientHeight < 80) el.scrollTop = el.scrollHeight;
 	}
 	/** Wrap a bubble in a `.row`, prefixing assistant rows with a mini avatar. */
 	buildRow(role, bubble) {
@@ -1388,7 +2802,7 @@ var SmoothAgentChatElement = class extends HTMLElement {
 				a.className = "src-title";
 				a.href = safeUrl;
 				a.target = "_blank";
-				a.rel = "noopener noreferrer";
+				a.rel = "noopener noreferrer nofollow";
 				titleEl = a;
 			} else {
 				titleEl = document.createElement("span");
@@ -1397,10 +2811,13 @@ var SmoothAgentChatElement = class extends HTMLElement {
 			titleEl.textContent = c.title || c.id || "Source";
 			li.appendChild(titleEl);
 			if (c.snippet) {
-				const snip = document.createElement("span");
-				snip.className = "src-snippet";
-				snip.textContent = c.snippet;
-				li.appendChild(snip);
+				const cleaned = cleanCitationSnippet(c.snippet);
+				if (cleaned) {
+					const snip = document.createElement("span");
+					snip.className = "src-snippet md";
+					snip.innerHTML = renderMarkdown(cleaned);
+					li.appendChild(snip);
+				}
 			}
 			list.appendChild(li);
 		}
@@ -1437,17 +2854,6 @@ var SmoothAgentChatElement = class extends HTMLElement {
 		this.controller.send(text);
 	}
 };
-function escapeHtml(value) {
-	return value.replace(/[&<>"']/g, (c) => {
-		switch (c) {
-			case "&": return "&amp;";
-			case "<": return "&lt;";
-			case ">": return "&gt;";
-			case "\"": return "&quot;";
-			default: return "&#39;";
-		}
-	});
-}
 /** Register the custom element once. Safe to call multiple times. */
 function defineChatWidget() {
 	if (typeof customElements !== "undefined" && !customElements.get("smooth-agent-chat")) customElements.define(ELEMENT_TAG, SmoothAgentChatElement);
@@ -1620,6 +3026,6 @@ function initChatWidgetLoader() {
 	else window.addEventListener("load", schedule, { once: true });
 }
 //#endregion
-export { ConversationController, ELEMENT_TAG, SmoothAgentChatElement, defineChatWidget, initChatWidgetLoader, mountChatWidget, mountFullPageChat };
+export { ConversationController, ELEMENT_TAG, PERSIST_VERSION, SmoothAgentChatElement, computeFingerprint, createWidgetStore, defineChatWidget, getOrCreateFingerprint, httpBaseFromWsEndpoint, initChatWidgetLoader, mountChatWidget, mountFullPageChat, storageKey };
 
 //# sourceMappingURL=index.js.map