@product7/product7-js 0.3.1 → 0.3.4

package/dist/product7-js.js

@@ -737,36 +737,7 @@
 		}
 
 		async identifyContact(data) {
-			await this.api._ensureSession();
-
-			if (this.api.mock) {
-				await delay$1(300);
-				return {
-					status: true,
-					data: {
-						contact_id: 'mock_contact_' + Date.now(),
-						email: data.email,
-						name: data.name || '',
-						is_new: true,
-					},
-				};
-			}
-
-			return this.api._makeRequest('/widget/messenger/identify', {
-				method: 'POST',
-				headers: {
-					'Content-Type': 'application/json',
-					Authorization: `Bearer ${this.api.sessionToken}`,
-				},
-				body: JSON.stringify({
-					email: data.email,
-					name: data.name || '',
-					phone: data.phone || '',
-					company: data.company || '',
-					avatar_url: data.avatar_url || '',
-					metadata: data.metadata || {},
-				}),
-			});
+			return this.api.identify(data);
 		}
 
 		async sendTypingIndicator(conversationId, isTyping) {
@@ -995,11 +966,16 @@
 			this.sessionToken = null;
 			this.sessionExpiry = null;
 			this.metadata = config.metadata || null;
+			this.identitySyncedToken = null;
 			this.mock = config.mock || false;
 			this.env = config.env || 'production';
 			this.baseURL = this._getBaseURL(config);
 
 			this._loadStoredSession();
+			this._loadStoredMetadata();
+			if (this.isSessionValid() && this.metadata) {
+				this.identitySyncedToken = this.sessionToken;
+			}
 		}
 
 		_getBaseURL(config) {
@@ -1039,20 +1015,17 @@
 				: envConfig.base;
 		}
 
-		async init(metadata = null) {
-			if (metadata) {
-				this.metadata = metadata;
+		async init(metadata = undefined) {
+			if (metadata !== undefined) {
+				this.setMetadata(metadata);
 			}
 
 			if (this.isSessionValid()) {
 				return { sessionToken: this.sessionToken };
 			}
 
-			if (!this.workspace || !this.metadata) {
-				throw new APIError$1(
-					400,
-					`Missing ${!this.workspace ? 'workspace' : 'user context'} for initialization`
-				);
+			if (!this.workspace) {
+				throw new APIError$1(400, 'Missing workspace for initialization');
 			}
 
 			if (this.mock) {
@@ -1065,6 +1038,7 @@
 		async _initMockSession() {
 			this.sessionToken = 'mock_session_' + Date.now();
 			this.sessionExpiry = new Date(Date.now() + 3600 * 1000);
+			this.identitySyncedToken = null;
 			this._storeSession();
 			return {
 				sessionToken: this.sessionToken,
@@ -1083,7 +1057,6 @@
 		async _initRealSession() {
 			const payload = {
 				workspace: this.workspace,
-				user: this.metadata,
 			};
 
 			try {
@@ -1096,6 +1069,7 @@
 
 				this.sessionToken = initData.sessionToken;
 				this.sessionExpiry = new Date(Date.now() + initData.expiresIn * 1000);
+				this.identitySyncedToken = null;
 				this._storeSession();
 
 				return {
@@ -1162,12 +1136,52 @@
 					this.sessionToken = null;
 					this.sessionExpiry = null;
 					await this.init();
+					await this._restoreIdentity();
 					return await method.apply(this, args);
 				}
 				throw error;
 			}
 		}
 
+		async identify(metadata = this.metadata) {
+			if (metadata !== undefined) {
+				this.setMetadata(metadata);
+			}
+
+			if (!this.metadata) {
+				throw new APIError$1(400, 'Missing user context for identify');
+			}
+
+			await this._ensureSession();
+
+			const payload = this._buildIdentifyPayload(this.metadata);
+
+			if (this.mock) {
+				this.identitySyncedToken = this.sessionToken;
+				return {
+					status: true,
+					identified: true,
+					data: {
+						user_id: payload.user_id || null,
+						email: payload.email || null,
+						name: payload.name || null,
+					},
+				};
+			}
+
+			const response = await this._makeRequest('/widget/identify', {
+				method: 'POST',
+				body: JSON.stringify(payload),
+				headers: {
+					'Content-Type': 'application/json',
+					Authorization: `Bearer ${this.sessionToken}`,
+				},
+			});
+
+			this.identitySyncedToken = this.sessionToken;
+			return response;
+		}
+
 		isSessionValid() {
 			return (
 				this.sessionToken && this.sessionExpiry && new Date() < this.sessionExpiry
@@ -1175,8 +1189,13 @@
 		}
 
 		setMetadata(metadata) {
-			this.metadata = metadata;
-			this._storeData('product7_metadata', metadata);
+			this.metadata = metadata || null;
+			this.identitySyncedToken = null;
+			if (this.metadata) {
+				this._storeData('product7_metadata', this.metadata);
+			} else {
+				this._removeData('product7_metadata');
+			}
 		}
 
 		getMetadata() {
@@ -1186,6 +1205,7 @@
 		clearSession() {
 			this.sessionToken = null;
 			this.sessionExpiry = null;
+			this.identitySyncedToken = null;
 			this._removeData('product7_session');
 			this._removeData('product7_metadata');
 		}
@@ -1211,6 +1231,14 @@
 				if (!stored) return false;
 
 				const sessionData = JSON.parse(stored);
+				if (
+					this.workspace &&
+					sessionData.workspace &&
+					sessionData.workspace !== this.workspace
+				) {
+					localStorage.removeItem('product7_session');
+					return false;
+				}
 				this.sessionToken = sessionData.token;
 				this.sessionExpiry = new Date(sessionData.expiry);
 
@@ -1220,6 +1248,32 @@
 			}
 		}
 
+		_loadStoredMetadata() {
+			if (this.metadata || typeof localStorage === 'undefined') return false;
+
+			try {
+				const session = localStorage.getItem('product7_session');
+				if (session) {
+					const sessionData = JSON.parse(session);
+					if (
+						this.workspace &&
+						sessionData.workspace &&
+						sessionData.workspace !== this.workspace
+					) {
+						return false;
+					}
+				}
+
+				const stored = localStorage.getItem('product7_metadata');
+				if (!stored) return false;
+
+				this.metadata = JSON.parse(stored);
+				return true;
+			} catch (error) {
+				return false;
+			}
+		}
+
 		_storeData(key, value) {
 			if (typeof localStorage !== 'undefined') {
 				localStorage.setItem(key, JSON.stringify(value));
@@ -1282,6 +1336,36 @@
 			const queryString = this._buildQueryParams(params);
 			return `${endpoint}${queryString ? '?' + queryString : ''}`;
 		}
+
+		_buildIdentifyPayload(metadata = {}) {
+			const payload = {
+				user_id: metadata.user_id,
+				email: metadata.email,
+				name: metadata.name,
+				avatar:
+					metadata.profile_picture || metadata.avatar_url || metadata.avatar,
+				attributes: metadata.custom_fields || {},
+			};
+
+			if (metadata.company) {
+				payload.company = metadata.company;
+			}
+
+			return payload;
+		}
+
+		async _restoreIdentity() {
+			if (
+				!this.metadata ||
+				!this.sessionToken ||
+				!this.identitySyncedToken ||
+				this.identitySyncedToken === this.sessionToken
+			) {
+				return;
+			}
+
+			await this.identify(this.metadata);
+		}
 	}
 
 	class APIService extends BaseAPIService {
@@ -1503,8 +1587,42 @@
 			return this.messenger.submitRating(conversationId, data);
 		}
 
+		async identify(metadata) {
+			await this._ensureSession();
+
+			if (this.mock) {
+				await new Promise((r) => setTimeout(r, 300));
+				return {
+					status: true,
+					data: {
+						contact_id: 'mock_contact_' + Date.now(),
+						email: metadata.email,
+						name: metadata.name || '',
+						is_new: true,
+					},
+				};
+			}
+
+			return this._makeRequest('/widget/messenger/identify', {
+				method: 'POST',
+				headers: {
+					'Content-Type': 'application/json',
+					Authorization: `Bearer ${this.sessionToken}`,
+				},
+				body: JSON.stringify({
+					user_id: metadata.user_id || null,
+					email: metadata.email || '',
+					name: metadata.name || '',
+					phone: metadata.phone || '',
+					company: metadata.company || '',
+					avatar_url: metadata.avatar_url || '',
+					metadata: metadata.custom_fields || {},
+				}),
+			});
+		}
+
 		async identifyContact(data) {
-			return this.messenger.identifyContact(data);
+			return this.identify(data);
 		}
 
 		async getHelpCollections(options) {
@@ -9492,7 +9610,9 @@
 
 			this._unsubscribe = this.state.subscribe((type, data) => {
 				if (type === 'connectionChange') {
-					const banner = this.element?.querySelector('.messenger-connection-banner');
+					const banner = this.element?.querySelector(
+						'.messenger-connection-banner'
+					);
 					if (banner) {
 						banner.style.display = data.connected ? 'none' : 'flex';
 					}
@@ -9542,9 +9662,10 @@
 					? this._renderEmptyState(isNewConversation)
 					: this._renderGroupedMessages(messages);
 
-			const defaultPlaceholder = this.options.composePlaceholder || 'Write a message...';
+			const defaultPlaceholder =
+				this.options.composePlaceholder || 'Write a message...';
 			const placeholder = isNewConversation
-				? (this.options.composePlaceholder || 'Start typing your message...')
+				? this.options.composePlaceholder || 'Start typing your message...'
 				: isClosed
 					? 'Conversation closed'
 					: defaultPlaceholder;
@@ -9565,7 +9686,7 @@
 				</div>
 				<div class="messenger-chat-header-info">
 					<span class="messenger-chat-title">${this._escapeHtml(teamName)}</span>
-					<span class="messenger-chat-subtitle">${isClosed ? 'Conversation resolved' : (this.state.responseTime || 'Typically replies within minutes')}</span>
+					<span class="messenger-chat-subtitle">${isClosed ? 'Conversation resolved' : this.state.responseTime || 'Typically replies within minutes'}</span>
 				</div>
 				<div class="messenger-chat-header-actions">
 					<button class="sdk-btn-icon sdk-close-btn messenger-mobile-close-btn" aria-label="Close">
@@ -9682,7 +9803,9 @@
 			const messageClass = isOwn
 				? 'messenger-message-own'
 				: 'messenger-message-received';
-			const timeStr = isLastInGroup ? this._formatMessageTime(message.timestamp) : '';
+			const timeStr = isLastInGroup
+				? this._formatMessageTime(message.timestamp)
+				: '';
 			const attachmentsHtml = this._renderMessageAttachments(message.attachments);
 			const isOptimistic = message.isOptimistic;
 
@@ -9696,9 +9819,10 @@
 			if (isOwn) {
 				const sentIndicator = isLastInGroup
 					? `<div class="messenger-message-meta messenger-message-meta-own">
-						${isOptimistic
-							? `<span class="messenger-message-sent-status">Sending…</span>`
-							: `<span class="messenger-message-sent-status">Sent</span>`
+						${
+							isOptimistic
+								? `<span class="messenger-message-sent-status">Sending…</span>`
+								: `<span class="messenger-message-sent-status">Sent</span>`
 						}
 						${timeStr ? `<span>·</span><span>${timeStr}</span>` : ''}
 					</div>`
@@ -10929,7 +11053,8 @@
 			const title = conversation.title || teamName;
 			const timeAgo = this._formatTimeAgo(conversation.lastMessageTime);
 			const preview = conversation.lastMessage
-				? conversation.lastMessage.substring(0, 48) + (conversation.lastMessage.length > 48 ? '...' : '')
+				? conversation.lastMessage.substring(0, 48) +
+					(conversation.lastMessage.length > 48 ? '...' : '')
 				: '';
 			const hasUnread = conversation.unread > 0;
 
@@ -11045,7 +11170,9 @@
 		}
 
 		_attachEvents() {
-			const recentCard = this.element.querySelector('.messenger-home-recent-card');
+			const recentCard = this.element.querySelector(
+				'.messenger-home-recent-card'
+			);
 			if (recentCard) {
 				recentCard.addEventListener('click', () => {
 					const convId = recentCard.dataset.conversationId;
@@ -11243,6 +11370,7 @@
 	class MessengerWidget extends BaseWidget {
 		constructor(options) {
 			super({ ...options, type: 'messenger' });
+			this._explicitOptions = options || {};
 			const resolvedTheme = options.theme || 'light';
 			const hasExplicitTextColor = Object.prototype.hasOwnProperty.call(
 				options,
@@ -11325,6 +11453,10 @@
 			this._handleConversationClosed = this._handleConversationClosed.bind(this);
 		}
 
+		_hasTrigger() {
+			return this.options.trigger === true || this.options.trigger === undefined;
+		}
+
 		_createInternalFeedbackWidget() {
 			try {
 				const widget = this.sdk.createWidget('button', {
@@ -11360,11 +11492,13 @@
 				this._feedbackWidget = this._createInternalFeedbackWidget();
 			}
 
-			this.launcher = new MessengerLauncher(this.messengerState, {
-				position: this.messengerOptions.position,
-				primaryColor: this.messengerOptions.primaryColor,
-			});
-			container.appendChild(this.launcher.render());
+			if (this._hasTrigger()) {
+				this.launcher = new MessengerLauncher(this.messengerState, {
+					position: this.messengerOptions.position,
+					primaryColor: this.messengerOptions.primaryColor,
+				});
+				container.appendChild(this.launcher.render());
+			}
 
 			this.panel = new MessengerPanel(this.messengerState, {
 				position: this.messengerOptions.position,
@@ -11499,23 +11633,13 @@
 
 		async _handleIdentifyContact(contactData) {
 			try {
-				const response = await this.apiService.identifyContact({
-					name: contactData.name,
+				// Route through sdk.identify() so the SDK-level identity state is updated
+				// and applyIdentity() handles the messenger state + WebSocket as a side effect.
+				const result = await this.sdk.identify({
 					email: contactData.email,
+					name: contactData.name,
 				});
-
-				if (response.status) {
-					console.log(
-						'[MessengerWidget] Contact identified:',
-						response.data.contact_id
-					);
-					this.messengerState.setIdentified(true, {
-						name: contactData.name,
-						email: contactData.email,
-					});
-				}
-
-				return response;
+				return result;
 			} catch (error) {
 				console.error('[MessengerWidget] Failed to identify contact:', error);
 				throw error;
@@ -11523,8 +11647,17 @@
 		}
 
 		markAsIdentified(name, email) {
-			this.messengerState.setIdentified(true, { name, email });
-			console.log('[MessengerWidget] Marked as identified:', email);
+			// Called externally by the app when the user is already known.
+			// No API call needed — identity was already established via sdk.identify().
+			this.applyIdentity({ name, email });
+		}
+
+		applyIdentity(metadata = {}) {
+			this.messengerState.setIdentified(true, metadata);
+
+			if (this.apiService?.sessionToken && !this.wsService?.isConnected) {
+				this._initWebSocket();
+			}
 		}
 
 		async _handleUploadFile(base64Data, filename) {
@@ -12035,6 +12168,42 @@
 			}
 		}
 
+		async _fetchAndApplySettings() {
+			try {
+				const response = await this.apiService.getMessengerSettings();
+				if (!response?.status || !response?.data) return;
+
+				const s = response.data;
+
+				// Only apply values that were NOT explicitly passed in options
+				if (s.team_name && !this._hasExplicitOption('teamName')) {
+					this.messengerOptions.teamName = s.team_name;
+					this.messengerState.teamName = s.team_name;
+				}
+				if (s.logo_url && !this._hasExplicitOption('logoUrl')) {
+					this.messengerOptions.logoUrl = s.logo_url;
+				}
+				if (s.greeting_message && !this._hasExplicitOption('greetingMessage')) {
+					this.messengerState.greetingMessage = s.greeting_message;
+				}
+				if (s.response_time && !this._hasExplicitOption('responseTime')) {
+					this.messengerState.responseTime = s.response_time;
+				}
+
+				// Notify views to re-render with new values
+				this.messengerState._notify('availabilityUpdate', {});
+			} catch (e) {
+				// non-fatal
+			}
+		}
+
+		_hasExplicitOption(key) {
+			return Object.prototype.hasOwnProperty.call(
+				this._explicitOptions || {},
+				key
+			);
+		}
+
 		async checkAgentAvailability() {
 			try {
 				const response = await this.apiService.checkAgentsOnline();
@@ -12180,6 +12349,9 @@
 			this._applyPreviewData();
 
 			if (this.messengerOptions.autoLoadData) {
+				// Fetch workspace settings and apply only if not explicitly configured
+				this._fetchAndApplySettings();
+
 				this.loadInitialData();
 
 				if (this.apiService?.sessionToken) {
@@ -12324,6 +12496,7 @@
 
 			SurveyWidget.removeDanglingElements();
 			this._renderSurvey();
+			this.state.isOpen = true;
 			this.surveyState.isVisible = true;
 			this.sdk.eventBus.emit('survey:shown', {
 				widget: this,
@@ -12333,6 +12506,7 @@
 		}
 
 		hide() {
+			this.state.isOpen = false;
 			this._closeSurvey();
 			return this;
 		}
@@ -12407,6 +12581,7 @@
 			this._attachSurveyEvents();
 
 			requestAnimationFrame(() => {
+				if (!this.surveyElement) return;
 				this.surveyElement.style.opacity = '1';
 				this.surveyElement.style.transform =
 					this.surveyOptions.position === 'center'
@@ -13544,6 +13719,7 @@
 		}
 
 		_closeSurvey(resetState = true, immediate = false) {
+			this.state.isOpen = false;
 			if (this._escapeHandler) {
 				document.removeEventListener('keydown', this._escapeHandler);
 				this._escapeHandler = null;
@@ -13606,6 +13782,22 @@
 			this.sdk.eventBus.emit('survey:closed', { widget: this });
 		}
 
+		open() {
+			return this.show();
+		}
+
+		close() {
+			return this.hide();
+		}
+
+		toggle() {
+			if (this.surveyState.isVisible) {
+				return this.hide();
+			}
+
+			return this.show();
+		}
+
 		destroy() {
 			this._closeSurvey(true, true);
 			super.destroy();
@@ -13723,6 +13915,7 @@
 		constructor(config = {}) {
 			this.config = this._validateAndMergeConfig(config);
 			this.initialized = false;
+			this.identified = false;
 			this.widgets = new Map();
 			this.eventBus = new EventBus();
 
@@ -13767,13 +13960,14 @@
 			this._injectStyles();
 
 			try {
-				const initData = await this.apiService.init(this.config.metadata);
+				const initData = await this.apiService.init();
 
 				if (initData.config) {
 					this.config = deepMerge(initData.config, this.config);
 				}
 
 				this.initialized = true;
+				const identifyResult = await this._syncConfiguredMetadataAfterInit();
 				this.eventBus.emit('sdk:initialized', {
 					config: this.config,
 					sessionToken: initData.sessionToken,
@@ -13784,6 +13978,7 @@
 					config: initData.config || {},
 					sessionToken: initData.sessionToken,
 					expiresIn: initData.expiresIn,
+					identified: Boolean(identifyResult?.identified),
 				};
 			} catch (error) {
 				this.eventBus.emit('sdk:error', { error });
@@ -13798,10 +13993,14 @@
 				);
 			}
 
+			const requestedType = type || 'button';
+			const normalizedType = this._normalizeWidgetType(requestedType);
 			const widgetId = generateId('widget');
-			const widgetConfig = this._getWidgetTypeConfig(type);
-			const explicitOptions = this._omitUndefined(options);
-			const widgetEnabled = this._isWidgetEnabled(type, {
+			const widgetConfig = this._getWidgetTypeConfig(normalizedType);
+			const explicitOptions = this._omitUndefined(
+				this._normalizeWidgetOptions(normalizedType, options)
+			);
+			const widgetEnabled = this._isWidgetEnabled(normalizedType, {
 				...widgetConfig,
 				...explicitOptions,
 			});
@@ -13816,15 +14015,35 @@
 			};
 
 			try {
-				const widget = WidgetFactory.create(type, widgetOptions);
+				const widget = WidgetFactory.create(normalizedType, widgetOptions);
 				this.widgets.set(widgetId, widget);
-				this.eventBus.emit('widget:created', { widget, type });
+				this.eventBus.emit('widget:created', {
+					widget,
+					type: requestedType,
+					internalType: normalizedType,
+				});
 				return widget;
 			} catch (error) {
 				throw new SDKError(`Failed to create widget: ${error.message}`, error);
 			}
 		}
 
+		createFeedbackWidget(options = {}) {
+			return this.createWidget('feedback', options);
+		}
+
+		createMessengerWidget(options = {}) {
+			return this.createWidget('messenger', options);
+		}
+
+		createChangelogWidget(options = {}) {
+			return this.createWidget('changelog', options);
+		}
+
+		createSurveyWidget(options = {}) {
+			return this.createWidget('survey', options);
+		}
+
 		getWidget(id) {
 			return this.widgets.get(id);
 		}
@@ -13943,7 +14162,7 @@
 				return null;
 			}
 
-			const surveyWidget = this.createWidget('survey', {
+			const surveyWidget = this.createSurveyWidget({
 				surveyId: normalizedOptions.surveyId,
 				surveyType:
 					normalizedOptions.surveyType || normalizedOptions.type || 'nps',
@@ -14177,18 +14396,34 @@
 				? this.config.widgets
 				: {};
 
-			const legacyTypeConfig = this._isPlainObject(this.config?.[type])
-				? this.config[type]
-				: {};
+			const mergedTypeConfig = this._getWidgetTypeAliases(type).reduce(
+				(config, alias) => {
+					const legacyTypeConfig = this._isPlainObject(this.config?.[alias])
+						? this.config[alias]
+						: {};
 
-			const namespacedTypeConfig = this._isPlainObject(widgetsConfig?.[type])
-				? widgetsConfig[type]
-				: {};
+					const namespacedTypeConfig = this._isPlainObject(widgetsConfig?.[alias])
+						? widgetsConfig[alias]
+						: {};
 
-			const mergedTypeConfig = deepMerge(legacyTypeConfig, namespacedTypeConfig);
+					return deepMerge(
+						config,
+						deepMerge(legacyTypeConfig, namespacedTypeConfig)
+					);
+				},
+				{}
+			);
 			return this._toCamelCaseObject(mergedTypeConfig);
 		}
 
+		_getWidgetTypeAliases(type) {
+			if (type === 'button') {
+				return ['button', 'feedback'];
+			}
+
+			return [type];
+		}
+
 		_isWidgetEnabled(type, options = {}) {
 			const typeConfig = this._getWidgetTypeConfig(type);
 			if (typeConfig.enabled === false) {
@@ -14231,6 +14466,31 @@
 			return normalized;
 		}
 
+		_normalizeWidgetType(type) {
+			if (type === 'feedback') {
+				return 'button';
+			}
+
+			return type;
+		}
+
+		_normalizeWidgetOptions(type, options = {}) {
+			if (!this._isPlainObject(options)) {
+				return options;
+			}
+
+			const normalizedOptions = { ...options };
+			if (
+				normalizedOptions.headless === true &&
+				normalizedOptions.trigger === undefined &&
+				type !== 'survey'
+			) {
+				normalizedOptions.trigger = false;
+			}
+
+			return normalizedOptions;
+		}
+
 		_omitUndefined(value) {
 			if (!this._isPlainObject(value)) {
 				return value;
@@ -14275,7 +14535,7 @@
 				return null;
 			}
 
-			const changelogWidget = this.createWidget('changelog', {
+			const changelogWidget = this.createChangelogWidget({
 				...defaults,
 				...configDefaults,
 				...explicitOptions,
@@ -14342,10 +14602,15 @@
 		}
 
 		setMetadata(metadata) {
+			if (metadata) {
+				this._validateMetadata(metadata);
+			}
+
 			this.config.metadata = metadata;
 			if (this.apiService) {
 				this.apiService.setMetadata(metadata);
 			}
+			this.identified = false;
 			this.eventBus.emit('metadata:updated', { metadata });
 		}
 
@@ -14356,11 +14621,53 @@
 			);
 		}
 
+		async identify(metadata = this.config.metadata) {
+			if (!this.initialized) {
+				throw new SDKError(
+					'SDK must be initialized before identifying users. Call init() first.'
+				);
+			}
+
+			if (!metadata) {
+				throw new SDKError(
+					'Identify requires metadata. Provide at least user_id or email.'
+				);
+			}
+
+			this._validateMetadata(metadata);
+			this.setMetadata(metadata);
+
+			try {
+				const response = await this.apiService.identify(metadata);
+				const configPatch = this._extractIdentifyConfig(response);
+				if (Object.keys(configPatch).length > 0) {
+					this.updateConfig(configPatch);
+				}
+
+				this.identified = true;
+				this._applyIdentityToWidgets(metadata);
+
+				const result = {
+					identified: true,
+					metadata: this.getMetadata(),
+					response,
+				};
+
+				this.eventBus.emit('sdk:identified', result);
+				return result;
+			} catch (error) {
+				this.identified = false;
+				this.eventBus.emit('sdk:error', { error, phase: 'identify' });
+				throw new SDKError(`Failed to identify user: ${error.message}`, error);
+			}
+		}
+
 		async reinitialize(newMetadata = null) {
 			this.apiService.clearSession();
 			this.initialized = false;
+			this.identified = false;
 
-			if (newMetadata) {
+			if (newMetadata !== null) {
 				this.setMetadata(newMetadata);
 			}
 
@@ -14389,10 +14696,11 @@
 
 		destroy() {
 			this.destroyAllWidgets();
-			this.eventBus.removeAllListeners();
+			this.eventBus.emit('sdk:destroyed');
+			this.eventBus.clear();
 			this.apiService.clearSession();
 			this.initialized = false;
-			this.eventBus.emit('sdk:destroyed');
+			this.identified = false;
 		}
 
 		hasFeedbackBeenSubmitted(cooldownDays = 30) {
@@ -14511,7 +14819,12 @@
 
 		_bindMethods() {
 			this.createWidget = this.createWidget.bind(this);
+			this.createFeedbackWidget = this.createFeedbackWidget.bind(this);
+			this.createMessengerWidget = this.createMessengerWidget.bind(this);
+			this.createChangelogWidget = this.createChangelogWidget.bind(this);
+			this.createSurveyWidget = this.createSurveyWidget.bind(this);
 			this.destroyWidget = this.destroyWidget.bind(this);
+			this.identify = this.identify.bind(this);
 			this.updateConfig = this.updateConfig.bind(this);
 		}
 
@@ -14547,6 +14860,49 @@
 						: undefined,
 			};
 		}
+
+		async _syncConfiguredMetadataAfterInit() {
+			if (
+				!this.config.metadata ||
+				this.apiService.identitySyncedToken === this.apiService.sessionToken
+			) {
+				return null;
+			}
+
+			try {
+				return await this.identify(this.config.metadata);
+			} catch (error) {
+				if (this.config.debug) {
+					console.warn('[Product7] Initial identify failed:', error);
+				}
+				return null;
+			}
+		}
+
+		_extractIdentifyConfig(response) {
+			const payload = this._isPlainObject(response?.data)
+				? response.data
+				: response || {};
+			const configPatch = this._isPlainObject(payload.config)
+				? payload.config
+				: {};
+
+			if (payload.last_feedback_at !== undefined) {
+				configPatch.last_feedback_at = payload.last_feedback_at;
+			} else if (payload.lastFeedbackAt !== undefined) {
+				configPatch.last_feedback_at = payload.lastFeedbackAt;
+			}
+
+			return this._omitUndefined(configPatch);
+		}
+
+		_applyIdentityToWidgets(metadata) {
+			for (const widget of this.widgets.values()) {
+				if (typeof widget.applyIdentity === 'function') {
+					widget.applyIdentity(metadata);
+				}
+			}
+		}
 	};
 
 	// --- Identify: transform flat user data into internal format ---
@@ -14629,9 +14985,21 @@
 		return obj;
 	}
 
+	function hasIdentifyMetadata(metadata = {}) {
+		return Object.values(metadata).some((value) => value !== undefined);
+	}
+
 	// --- Ensure SDK is initialized (shared by widget inits) ---
 
 	async function ensureSDK(options) {
+		if (
+			Product7._sdk &&
+			options.organization &&
+			Product7._sdk.config.workspace !== options.organization
+		) {
+			Product7.destroy();
+		}
+
 		if (Product7._sdk) return Product7._sdk;
 
 		if (options.organization) {
@@ -14674,63 +15042,58 @@
 		async identify(data = {}, callback) {
 			try {
 				const transformed = transformIdentifyData(data);
-				Product7._organization = transformed.workspace;
+				Product7._organization =
+					transformed.workspace || Product7._organization || null;
 
 				const config = cleanUndefined({
-					workspace: transformed.workspace,
-					metadata: transformed.metadata,
+					workspace: Product7._organization,
 					debug: transformed.debug,
 					mock: transformed.mock,
 					env: transformed.env,
 					apiUrl: transformed.apiUrl,
 				});
 
-				const sdk = new Product7$1(config);
-				const initData = await sdk.init();
-
-				Product7._sdk = sdk;
-				Product7._identified = true;
+				let sdk = Product7._sdk;
+				const requiresNewSDK =
+					!sdk || (config.workspace && sdk.config.workspace !== config.workspace);
 
-				// Sync custom attributes + segments via /widget/identify
-				if (transformed.metadata && sdk.apiService?.sessionToken) {
-					try {
-						const identifyPayload = {
-							user_id: transformed.metadata.user_id,
-							email: transformed.metadata.email,
-							name: transformed.metadata.name,
-							avatar: transformed.metadata.profile_picture,
-							attributes: transformed.metadata.custom_fields || {},
-						};
-						if (transformed.metadata.company) {
-							identifyPayload.company = transformed.metadata.company;
-						}
-						await sdk.apiService._makeRequest('/widget/identify', {
-							method: 'POST',
-							body: JSON.stringify(identifyPayload),
-							headers: {
-								'Content-Type': 'application/json',
-								Authorization: `Bearer ${sdk.apiService.sessionToken}`,
-							},
-						});
-					} catch (identifyErr) {
-						if (config.debug) {
-							console.warn('[Product7] Attribute sync failed:', identifyErr);
-						}
+				if (requiresNewSDK) {
+					if (Product7._sdk) {
+						Product7.destroy();
+						Product7._organization = config.workspace || null;
 					}
+					sdk = new Product7$1(config);
+					Product7._sdk = sdk;
 				}
 
+				const initData = sdk.initialized
+					? {
+							alreadyInitialized: true,
+							sessionToken: sdk.apiService?.sessionToken,
+						}
+					: await sdk.init();
+
+				const identifyData = hasIdentifyMetadata(transformed.metadata)
+					? await sdk.identify(transformed.metadata)
+					: null;
+				Product7._identified = Boolean(identifyData?.identified);
+
 				Product7._flushQueue();
 
 				if (typeof window !== 'undefined' && typeof CustomEvent !== 'undefined') {
 					window.dispatchEvent(
 						new CustomEvent('Product7Ready', {
-							detail: { sdk, config, initData },
+							detail: { sdk, config: sdk.config, initData, identifyData },
 						})
 					);
 				}
 
 				if (typeof callback === 'function') callback(null);
-				return initData;
+				return {
+					...initData,
+					identified: Product7._identified,
+					identify: identifyData,
+				};
 			} catch (error) {
 				console.error('[Product7] Identify failed:', error);
 
@@ -14789,7 +15152,7 @@
 			if (!options.placement) {
 				widgetOptions.autoShow = false;
 				widgetOptions.displayMode = 'modal';
-				widgetOptions._noTriggerButton = true;
+				widgetOptions.headless = true;
 			} else {
 				// Trigger button is always visible when placement is set
 				widgetOptions.suppressAfterSubmission = false;
@@ -14797,7 +15160,7 @@
 			}
 
 			try {
-				const widget = sdk.createWidget('button', widgetOptions);
+				const widget = sdk.createFeedbackWidget(widgetOptions);
 				widget.mount();
 
 				if (options.placement) {
@@ -14836,13 +15199,13 @@
 				if (options.setBoard) {
 					Product7._feedbackWidget.options.boardName = options.setBoard;
 				}
-				Product7._feedbackWidget.openPanel();
+				Product7._feedbackWidget.open();
 			}
 		},
 
 		closeFeedback() {
 			if (Product7._feedbackWidget) {
-				Product7._feedbackWidget.closePanel();
+				Product7._feedbackWidget.close();
 			}
 		},
 
@@ -14901,7 +15264,7 @@
 			widgetOptions.enabled = true;
 
 			try {
-				const widget = sdk.createWidget('messenger', widgetOptions);
+				const widget = sdk.createMessengerWidget(widgetOptions);
 				widget.mount();
 				widget.show();