@smooai/chat-widget 0.5.2 → 0.7.0

package/dist/chat-widget.global.js

@@ -18,6 +18,7 @@ var SmoothAgentChat = (function(exports) {
 			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.",
@@ -26,6 +27,9 @@ var SmoothAgentChat = (function(exports) {
 			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",
@@ -609,6 +613,451 @@ var SmoothAgentChat = (function(exports) {
 		throw new ProtocolError("UNEXPECTED_EVENT", `Expected immediate_response, got "${event.type}"`, event.requestId);
 	}
 	//#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 node_modules/.pnpm/zustand@5.0.14/node_modules/zustand/esm/vanilla.mjs
+	const createStoreImpl = (createState) => {
+		let state;
+		const listeners = /* @__PURE__ */ new Set();
+		const setState = (partial, replace) => {
+			const nextState = typeof partial === "function" ? partial(state) : partial;
+			if (!Object.is(nextState, state)) {
+				const previousState = state;
+				state = (replace != null ? replace : typeof nextState !== "object" || nextState === null) ? nextState : Object.assign({}, state, nextState);
+				listeners.forEach((listener) => listener(state, previousState));
+			}
+		};
+		const getState = () => state;
+		const getInitialState = () => initialState;
+		const subscribe = (listener) => {
+			listeners.add(listener);
+			return () => listeners.delete(listener);
+		};
+		const api = {
+			setState,
+			getState,
+			getInitialState,
+			subscribe
+		};
+		const initialState = state = createState(setState, getState, api);
+		return api;
+	};
+	const createStore = ((createState) => createState ? createStoreImpl(createState) : createStoreImpl);
+	//#endregion
+	//#region node_modules/.pnpm/zustand@5.0.14/node_modules/zustand/esm/middleware.mjs
+	function createJSONStorage(getStorage, options) {
+		let storage;
+		try {
+			storage = getStorage();
+		} catch (e) {
+			return;
+		}
+		return {
+			getItem: (name) => {
+				var _a;
+				const parse = (str2) => {
+					if (str2 === null) return null;
+					return JSON.parse(str2, options == null ? void 0 : options.reviver);
+				};
+				const str = (_a = storage.getItem(name)) != null ? _a : null;
+				if (str instanceof Promise) return str.then(parse);
+				return parse(str);
+			},
+			setItem: (name, newValue) => storage.setItem(name, JSON.stringify(newValue, options == null ? void 0 : options.replacer)),
+			removeItem: (name) => storage.removeItem(name)
+		};
+	}
+	const toThenable = (fn) => (input) => {
+		try {
+			const result = fn(input);
+			if (result instanceof Promise) return result;
+			return {
+				then(onFulfilled) {
+					return toThenable(onFulfilled)(result);
+				},
+				catch(_onRejected) {
+					return this;
+				}
+			};
+		} catch (e) {
+			return {
+				then(_onFulfilled) {
+					return this;
+				},
+				catch(onRejected) {
+					return toThenable(onRejected)(e);
+				}
+			};
+		}
+	};
+	const persistImpl = (config, baseOptions) => (set, get, api) => {
+		let options = {
+			storage: createJSONStorage(() => window.localStorage),
+			partialize: (state) => state,
+			version: 0,
+			merge: (persistedState, currentState) => ({
+				...currentState,
+				...persistedState
+			}),
+			...baseOptions
+		};
+		let hasHydrated = false;
+		let hydrationVersion = 0;
+		const hydrationListeners = /* @__PURE__ */ new Set();
+		const finishHydrationListeners = /* @__PURE__ */ new Set();
+		let storage = options.storage;
+		if (!storage) return config((...args) => {
+			console.warn(`[zustand persist middleware] Unable to update item '${options.name}', the given storage is currently unavailable.`);
+			set(...args);
+		}, get, api);
+		const setItem = () => {
+			const state = options.partialize({ ...get() });
+			return storage.setItem(options.name, {
+				state,
+				version: options.version
+			});
+		};
+		const savedSetState = api.setState;
+		api.setState = (state, replace) => {
+			savedSetState(state, replace);
+			return setItem();
+		};
+		const configResult = config((...args) => {
+			set(...args);
+			return setItem();
+		}, get, api);
+		api.getInitialState = () => configResult;
+		let stateFromStorage;
+		const hydrate = () => {
+			var _a, _b;
+			if (!storage) return;
+			const currentVersion = ++hydrationVersion;
+			hasHydrated = false;
+			hydrationListeners.forEach((cb) => {
+				var _a2;
+				return cb((_a2 = get()) != null ? _a2 : configResult);
+			});
+			const postRehydrationCallback = ((_b = options.onRehydrateStorage) == null ? void 0 : _b.call(options, (_a = get()) != null ? _a : configResult)) || void 0;
+			return toThenable(storage.getItem.bind(storage))(options.name).then((deserializedStorageValue) => {
+				if (deserializedStorageValue) if (typeof deserializedStorageValue.version === "number" && deserializedStorageValue.version !== options.version) {
+					if (options.migrate) {
+						const migration = options.migrate(deserializedStorageValue.state, deserializedStorageValue.version);
+						if (migration instanceof Promise) return migration.then((result) => [true, result]);
+						return [true, migration];
+					}
+					console.error(`State loaded from storage couldn't be migrated since no migrate function was provided`);
+				} else return [false, deserializedStorageValue.state];
+				return [false, void 0];
+			}).then((migrationResult) => {
+				var _a2;
+				if (currentVersion !== hydrationVersion) return;
+				const [migrated, migratedState] = migrationResult;
+				stateFromStorage = options.merge(migratedState, (_a2 = get()) != null ? _a2 : configResult);
+				set(stateFromStorage, true);
+				if (migrated) return setItem();
+			}).then(() => {
+				if (currentVersion !== hydrationVersion) return;
+				postRehydrationCallback?.(get(), void 0);
+				stateFromStorage = get();
+				hasHydrated = true;
+				finishHydrationListeners.forEach((cb) => cb(stateFromStorage));
+			}).catch((e) => {
+				if (currentVersion !== hydrationVersion) return;
+				postRehydrationCallback?.(void 0, e);
+			});
+		};
+		api.persist = {
+			setOptions: (newOptions) => {
+				options = {
+					...options,
+					...newOptions
+				};
+				if (newOptions.storage) storage = newOptions.storage;
+			},
+			clearStorage: () => {
+				storage?.removeItem(options.name);
+			},
+			getOptions: () => options,
+			rehydrate: () => hydrate(),
+			hasHydrated: () => hasHydrated,
+			onHydrate: (cb) => {
+				hydrationListeners.add(cb);
+				return () => {
+					hydrationListeners.delete(cb);
+				};
+			},
+			onFinishHydration: (cb) => {
+				finishHydrationListeners.add(cb);
+				return () => {
+					finishHydrationListeners.delete(cb);
+				};
+			}
+		};
+		if (!options.skipHydration) hydrate();
+		return stateFromStorage || configResult;
+	};
+	const persist = persistImpl;
+	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 src/conversation.ts
 	/**
 	* ConversationController — the bridge between the widget UI and the
@@ -620,13 +1069,41 @@ var SmoothAgentChat = (function(exports) {
 	* 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;
@@ -667,40 +1144,89 @@ var SmoothAgentChat = (function(exports) {
 		}
 		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;
@@ -731,20 +1257,95 @@ var SmoothAgentChat = (function(exports) {
 		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));
@@ -752,6 +1353,105 @@ var SmoothAgentChat = (function(exports) {
 			}
 		}
 		/**
+		* 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`.
 		*/
@@ -853,12 +1553,170 @@ var SmoothAgentChat = (function(exports) {
 				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");
 		}
@@ -874,6 +1732,305 @@ var SmoothAgentChat = (function(exports) {
 	*/
 	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.
@@ -1198,6 +2355,50 @@ var SmoothAgentChat = (function(exports) {
 }
 @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; }
@@ -1357,6 +2558,17 @@ var SmoothAgentChat = (function(exports) {
 }
 .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; }
@@ -1435,6 +2647,61 @@ var SmoothAgentChat = (function(exports) {
 .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; }
 
@@ -1476,24 +2743,6 @@ var SmoothAgentChat = (function(exports) {
 		/** 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;
@@ -1510,8 +2759,12 @@ var SmoothAgentChat = (function(exports) {
 			_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);
@@ -1519,6 +2772,11 @@ var SmoothAgentChat = (function(exports) {
 			_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() {
@@ -1527,6 +2785,7 @@ var SmoothAgentChat = (function(exports) {
 		}
 		disconnectedCallback() {
 			this.mounted = false;
+			this.resetReveal();
 			this.controller?.disconnect();
 			this.controller = null;
 		}
@@ -1552,7 +2811,7 @@ var SmoothAgentChat = (function(exports) {
 		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() {
@@ -1573,6 +2832,7 @@ var SmoothAgentChat = (function(exports) {
 				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,
@@ -1581,6 +2841,9 @@ var SmoothAgentChat = (function(exports) {
 				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
 			};
@@ -1592,11 +2855,11 @@ var SmoothAgentChat = (function(exports) {
 				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;
@@ -1606,9 +2869,14 @@ var SmoothAgentChat = (function(exports) {
 					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;
@@ -1631,8 +2899,16 @@ var SmoothAgentChat = (function(exports) {
                     <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">
@@ -1640,12 +2916,14 @@ var SmoothAgentChat = (function(exports) {
                     <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>
@@ -1654,7 +2932,7 @@ var SmoothAgentChat = (function(exports) {
                         <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 = `
@@ -1667,6 +2945,7 @@ var SmoothAgentChat = (function(exports) {
         `;
 			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");
@@ -1691,9 +2970,16 @@ var SmoothAgentChat = (function(exports) {
 				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();
@@ -1709,6 +2995,11 @@ var SmoothAgentChat = (function(exports) {
 			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;
 			}
@@ -1788,15 +3079,186 @@ var SmoothAgentChat = (function(exports) {
 			}
 			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();
@@ -1824,9 +3286,35 @@ var SmoothAgentChat = (function(exports) {
 			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");
@@ -1849,12 +3337,94 @@ var SmoothAgentChat = (function(exports) {
 					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) {
@@ -1911,7 +3481,7 @@ var SmoothAgentChat = (function(exports) {
 					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");
@@ -1920,10 +3490,13 @@ var SmoothAgentChat = (function(exports) {
 				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);
 			}
@@ -1960,17 +3533,6 @@ var SmoothAgentChat = (function(exports) {
 			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);