@strivacity/sdk-nuxt 3.0.0-rc.0 → 3.0.1

package/CHANGELOG.md

@@ -1,3 +1,27 @@
+## 3.0.1 (2026-04-20)
+
+### 🩹 Fixes
+
+- handle language parameter from response body url correctly ([e42294b](https://github.com/Strivacity/sdk-js/commit/e42294b))
+
+### 🧱 Updated Dependencies
+
+- Updated sdk-core to 3.0.1
+
+# 3.0.0 (2026-04-09)
+
+### 🚀 Features
+
+- ⚠️  NativeFlow entry function now returns an object instead of a string ([9a8942d](https://github.com/Strivacity/sdk-js/commit/9a8942d))
+
+### ⚠️  Breaking Changes
+
+- NativeFlow entry function now returns an object instead of a string  ([9a8942d](https://github.com/Strivacity/sdk-js/commit/9a8942d))
+
+### 🧱 Updated Dependencies
+
+- Updated sdk-core to 3.0.0
+
 ## 3.0.0-rc.0 (2026-02-18)
 
 ### 🚀 Features

package/README.md

@@ -1,29 +1,39 @@
 # @strivacity/sdk-nuxt
 
-> **The SDK supports Nuxt version 3 and above**
+A Nuxt 3 module that integrates Strivacity's policy-driven authentication journeys into your application using the OAuth 2.0 PKCE flow. Supports `redirect`, `popup`, `native`, and `embedded` modes.
 
-## Example App
+See our [Developer Portal](https://www.strivacity.com/learn-support/developer-hub) to get started with developing with the Strivacity product.
+
+## Overview
+
+This SDK allows you to integrate Strivacity's policy-driven journeys into your Nuxt 3 application. It registers itself as a Nuxt module and automatically provides the `useStrivacity` composable and `StyLoginRenderer` component throughout your application without needing explicit imports. The SDK uses the OAuth 2.0 PKCE flow to authenticate with Strivacity. For detailed configuration options, available modes, and advanced usage refer to the [`@strivacity/sdk-core` documentation](https://github.com/Strivacity/sdk-js/blob/main/packages/sdk-core/README.md).
+
+## Demo Application
 
 - [Example app](https://github.com/Strivacity/sdk-js/tree/main/apps/nuxt)
 
-### Install
+## Requirements
+
+- Nuxt: 3+
+
+## Install
 
 ```bash
 npm install @strivacity/sdk-nuxt
 ```
 
-### Usage
+## Usage
 
-#### Add this to your nuxt config file:
+### Initialization
 
-```js
-import { defineNuxtConfig } from 'nuxt/config';
+Register the SDK as a Nuxt module in `nuxt.config.ts`:
 
+```ts
+// nuxt.config.ts
 export default defineNuxtConfig({
-	...
 	modules: ['@strivacity/sdk-nuxt'],
 	strivacity: {
-		mode: 'redirect', // or 'popup' or 'native'
+		mode: 'redirect', // or 'popup', 'native', 'embedded'
 		issuer: 'https://<YOUR_DOMAIN>',
 		scopes: ['openid', 'profile'],
 		clientId: '<YOUR_CLIENT_ID>',
@@ -32,22 +42,24 @@ export default defineNuxtConfig({
 });
 ```
 
-#### How to use the SDK in your components:
-
-##### Redirect or popup mode
+Use the auto-imported `useStrivacity` composable in any component to access authentication state:
 
-When using redirect or popup mode, the authentication flow involves two main components: a login page that initiates the authentication process, and a callback page that handles the response from the identity provider.
-
-In **redirect mode**, users are redirected to the identity provider's login page in the same browser window. After successful authentication, they are redirected back to your application's callback URL.
+```vue
+<script setup>
+const { loading, isAuthenticated, idTokenClaims } = useStrivacity();
+</script>
+```
 
-In **popup mode**, the authentication happens in a popup window, allowing the main application to remain open while the user authenticates.
+### Redirect / Popup mode
 
-###### Login page example
+In `redirect` mode the user is taken to the identity provider in the same window; in `popup` mode authentication happens in a popup. Both are initiated the same way from code.
 
-The login page is where users start the authentication process. This component automatically triggers the login flow when the page loads, redirecting users to the identity provider for authentication.
+#### Login page example
 
 ```vue
 <script setup>
+import { onMounted } from 'vue';
+
 const { login } = useStrivacity();
 
 onMounted(() => {
@@ -62,12 +74,14 @@ onMounted(() => {
 </template>
 ```
 
-###### Callback page example
+#### Callback page example
 
-The callback page handles the response from the identity provider after successful authentication. It processes the authentication result, extracts the tokens, and redirects users to their intended destination (typically a protected page like a profile or dashboard).
+The callback page handles the response from the identity provider. It calls `handleCallback()` and redirects to `/profile` on success:
 
 ```vue
 <script setup>
+import { onMounted } from 'vue';
+
 const router = useRouter();
 const { handleCallback } = useStrivacity();
 
@@ -88,11 +102,7 @@ onMounted(async () => {
 </template>
 ```
 
-###### Profile page example
-
-The profile page displays user information and authentication details after successful login. It uses the `useStrivacity` composable to access the authentication state and display relevant data such as access tokens, ID token claims, and expiration status.
-
-We check if the user is authenticated and display their profile information. If the user is not authenticated, we redirect them to the login page.
+#### Profile page example
 
 ```vue
 <script setup>
@@ -103,33 +113,23 @@ const { loading, isAuthenticated, accessToken, accessTokenExpired, accessTokenEx
 	<section>
 		<h1 v-if="loading">Loading...</h1>
 		<dl v-else>
-			<dt>
-				<strong>accessToken</strong>
-			</dt>
+			<dt><strong>accessToken</strong></dt>
 			<dd>
 				<pre>{{ JSON.stringify(accessToken) }}</pre>
 			</dd>
-			<dt>
-				<strong>refreshToken</strong>
-			</dt>
+			<dt><strong>refreshToken</strong></dt>
 			<dd>
 				<pre>{{ JSON.stringify(refreshToken) }}</pre>
 			</dd>
-			<dt>
-				<strong>accessTokenExpired</strong>
-			</dt>
+			<dt><strong>accessTokenExpired</strong></dt>
 			<dd>
 				<pre>{{ JSON.stringify(accessTokenExpired) }}</pre>
 			</dd>
-			<dt>
-				<strong>accessTokenExpirationDate</strong>
-			</dt>
+			<dt><strong>accessTokenExpirationDate</strong></dt>
 			<dd>
 				<pre>{{ accessTokenExpirationDate ? new Date(accessTokenExpirationDate * 1000).toLocaleString() : JSON.stringify(null) }}</pre>
 			</dd>
-			<dt>
-				<strong>claims</strong>
-			</dt>
+			<dt><strong>claims</strong></dt>
 			<dd>
 				<pre>{{ JSON.stringify(idTokenClaims, null, 2) }}</pre>
 			</dd>
@@ -138,14 +138,14 @@ const { loading, isAuthenticated, accessToken, accessTokenExpired, accessTokenEx
 </template>
 ```
 
-###### Logout page example
-
-The logout page handles user logout by terminating their session. The `postLogoutRedirectUri` parameter is optional and specifies where users should be redirected after logout. If not provided, users will be redirected to the identity provider's logout page.
+#### Logout page example
 
-This URI must be configured in the Admin Console as an allowed post-logout redirect URI for your application.
+The `postLogoutRedirectUri` parameter is optional and specifies where users are redirected after logout. This URI must be configured in the Admin Console as an allowed post-logout redirect URI.
 
 ```vue
 <script setup>
+import { onMounted } from 'vue';
+
 const router = useRouter();
 const { isAuthenticated, logout } = useStrivacity();
 
@@ -165,12 +165,12 @@ onMounted(async () => {
 </template>
 ```
 
-###### Component example
-
-Here's a simple component example that demonstrates how to use the SDK in a component with login/logout functionality:
+#### Component example
 
 ```vue
 <script setup>
+import { computed } from 'vue';
+
 const { isAuthenticated, idTokenClaims, login, logout } = useStrivacity();
 const name = computed(() => `${idTokenClaims.value?.given_name} ${idTokenClaims.value?.family_name}`);
 </script>
@@ -187,15 +187,11 @@ const name = computed(() => `${idTokenClaims.value?.given_name} ${idTokenClaims.
 </template>
 ```
 
-##### Native mode
+### Native mode
 
-If you are using `native` mode, you can use the `StyLoginRenderer` component to render the login UI.
+In `native` mode the auto-imported `StyLoginRenderer` component renders the authentication UI inline using your custom widget components. You can define custom components for each input type; see [Example widgets](https://github.com/Strivacity/sdk-js/tree/main/apps/nuxt/app/components/widgets).
 
-To customize the UI components used in the authentication flows, define the `widgets` object in your component.
-
-###### Example widgets
-
-The example widgets use SCSS for styling and Luxon for date handling. You'll need to install these dependencies:
+The example widgets use SCSS for styling and Luxon for date handling:
 
 ```bash
 npm install sass luxon
@@ -232,84 +228,46 @@ export const widgets = {
 };
 ```
 
-You can find example widgets here: [Example widgets](https://github.com/Strivacity/sdk-js/tree/main/apps/nuxt/app/components)
-
-###### Login page example
+#### Login page example
 
-The native mode login page provides a fully customizable authentication experience rendered directly within your application. Unlike redirect or popup modes, native mode keeps users on your site throughout the entire authentication process using the `StyLoginRenderer` component.
-
-This example demonstrates how to handle session management, implement callback functions for various authentication events, and manage URL parameters for session continuity.
+The login page extracts `session_id` and optionally `language` from the URL on load, cleans up the URL, and passes them to the renderer. When a `session_id` is present the renderer calls `startSession(sessionId)` to resume the existing flow instead of starting a new one. When a `language` parameter is present it overrides `uiLocales` to display the authentication UI in the specified language.
 
 ```vue
 <script setup lang="ts">
-import { FallbackError, useStrivacity, type LoginFlowState } from '@strivacity/sdk-nuxt';
-import { widgets } from './components/widgets'; // Import your custom widgets
+import { ref } from 'vue';
+import type { FallbackError, LoginFlowState } from '@strivacity/sdk-nuxt';
+import { widgets } from '~/components/widgets';
 
 const router = useRouter();
-const { options, login } = useStrivacity();
 const sessionId = ref<string | null>(null);
 
-/**
- * Extract session_id from URL parameters and clean up the URL
- * This is necessary for maintaining session state across external login providers
- */
-onMounted(() => {
-	if (process.client && window.location.search !== '') {
-		const url = new URL(window.location.href);
-		const sid = url.searchParams.get('session_id');
-		sessionId.value = sid;
-		url.search = '';
-		window.history.replaceState({}, '', url.toString());
-	}
-});
+if (window.location.search !== '') {
+	const url = new URL(window.location.href);
+	sessionId.value = url.searchParams.get('session_id');
+	url.search = '';
+	history.replaceState({}, '', url.toString());
+}
 
-/**
- * Called when authentication is successful
- * Redirects user to the profile page
- */
 const onLogin = async () => {
 	await router.push('/profile');
 };
 
-/**
- * Called when native flow cannot handle the authentication
- * Falls back to redirect mode by navigating to the provided URL
- * @param error - FallbackError containing the fallback URL and message
- */
 const onFallback = (error: FallbackError) => {
 	if (error.url) {
-		console.log(`Fallback: ${error.url}`);
-		if (process.client) {
-			window.location.href = error.url.toString();
-		}
+		window.location.href = error.url.toString();
 	} else {
-		console.error(`FallbackError without URL: ${error.message}`);
 		alert(error);
 	}
 };
 
-/**
- * Called when an error occurs during the authentication process
- * @param error - Error message describing what went wrong
- */
 const onError = (error: string) => {
-	console.error(`Error: ${error}`);
 	alert(error);
 };
 
-/**
- * Called when the authentication flow wants to display a global message
- * @param message - Message to display to the user
- */
 const onGlobalMessage = (message: string) => {
 	alert(message);
 };
 
-/**
- * Called when the authentication flow transitions between states
- * Useful for tracking flow progress and inject custom logic such as logging or analytics
- * @param params - Object containing previous and current flow states
- */
 const onBlockReady = ({ previousState, state }: { previousState: LoginFlowState; state: LoginFlowState }) => {
 	console.log('previousState', previousState);
 	console.log('state', state);
@@ -329,32 +287,30 @@ const onBlockReady = ({ previousState, state }: { previousState: LoginFlowState;
 </template>
 ```
 
-###### Callback page example
-
-The native mode callback page handles authentication responses when external identity providers redirect back to your application. This page checks for session IDs in the URL parameters and either continues the native flow or falls back to standard callback handling.
+#### Callback page example
 
-This component is essential for handling social login providers (like Google, Facebook, etc.) that require redirect-based authentication even within native mode flows.
+When a `session_id` is present in the URL the native flow is resumed by forwarding it to the login page. Otherwise the standard `handleCallback()` path is used:
 
 ```vue
 <script setup>
-const query = computed(() => (process.client ? Object.fromEntries(new URLSearchParams(window.location.search)) : {}));
+import { onMounted, computed } from 'vue';
+
+const query = computed(() => Object.fromEntries(new URLSearchParams(window.location.search)));
 const router = useRouter();
 const { handleCallback } = useStrivacity();
 
 onMounted(async () => {
-	if (process.client) {
-		const url = new URL(location.href);
-		const sessionId = url.searchParams.get('session_id');
+	const url = new URL(location.href);
+	const sessionId = url.searchParams.get('session_id');
 
-		if (sessionId) {
-			await router.push(`/login?session_id=${sessionId}`);
-		} else {
-			try {
-				await handleCallback();
-				await router.push('/profile');
-			} catch (error) {
-				console.error('Error during callback handling:', error);
-			}
+	if (sessionId) {
+		await router.push(`/login?session_id=${sessionId}`);
+	} else {
+		try {
+			await handleCallback();
+			await router.push('/profile');
+		} catch (error) {
+			console.error('Error during callback handling:', error);
 		}
 	}
 });
@@ -374,28 +330,80 @@ onMounted(async () => {
 </template>
 ```
 
-###### Profile page example
+#### Entry page example
+
+The entry page processes flows started by an external process (e.g. password reset) by calling `entry()` to extract the necessary parameters to resume the flow and forwarding them to the callback page:
+
+```vue
+<script setup>
+import { onMounted } from 'vue';
+
+const router = useRouter();
+const { entry } = useStrivacity();
+
+onMounted(async () => {
+	try {
+		const data = await entry();
+
+		if (data && Object.keys(data).length > 0) {
+			await router.push(`/callback?${new URLSearchParams(data).toString()}`);
+		} else {
+			await router.push('/');
+		}
+	} catch (error) {
+		console.error('Entry failed:', error);
+		await router.push('/');
+	}
+});
+</script>
+```
+
+#### Profile page example
 
 Same as the profile page example in redirect/popup mode.
 
-###### Logout page example
+#### Logout page example
 
 Same as the logout page example in redirect/popup mode.
 
+### Embedded mode
+
+In `embedded` mode the `<sty-login>` web component (loaded via `bundle.js` from the cluster) handles rendering. Import the bundle in a Nuxt plugin to register the Strivacity web components:
+
+```ts
+// plugins/strivacity-bundle.client.ts
+export default defineNuxtPlugin(() => {
+	const config = useRuntimeConfig();
+	void import(`${config.public.strivacity.issuer}/assets/components/bundle.js`);
+});
+```
+
+```ts
+// nuxt.config.ts
+export default defineNuxtConfig({
+	modules: ['@strivacity/sdk-nuxt'],
+	strivacity: {
+		mode: 'embedded',
+		issuer: 'https://<YOUR_DOMAIN>',
+		scopes: ['openid', 'profile'],
+		clientId: '<YOUR_CLIENT_ID>',
+		redirectUri: '<YOUR_REDIRECT_URI>',
+	},
+});
+```
+
 ## Logging
 
 The SDK supports optional logging to help you debug authentication flows and monitor SDK behavior. You can enable the built-in console logger or provide your own custom logger implementation.
 
 ### Using the Default Logger
 
-Enable the default console logger by adding the `logging` option in your Nuxt configuration:
+Enable the default console logger by adding the `logging` option in `nuxt.config.ts`:
 
-```typescript
-import { defineNuxtConfig } from 'nuxt/config';
+```ts
 import { DefaultLogging } from '@strivacity/sdk-nuxt';
 
 export default defineNuxtConfig({
-	ssr: false,
 	modules: ['@strivacity/sdk-nuxt'],
 	strivacity: {
 		mode: 'redirect',
@@ -403,16 +411,14 @@ export default defineNuxtConfig({
 		scopes: ['openid', 'profile'],
 		clientId: '<YOUR_CLIENT_ID>',
 		redirectUri: '<YOUR_REDIRECT_URI>',
-		logging: DefaultLogging, // Enable built-in console logging
+		logging: DefaultLogging,
 	},
 });
 ```
 
-The default logger writes to the browser console and automatically prefixes messages with a correlation ID when available (via the `xEventId` property).
-
 ### Creating a Custom Logger
 
-You can provide your own logger by implementing the `SDKLogging` interface with four methods: `debug`, `info`, `warn`, and `error`. An optional `xEventId` property is honored for log correlation.
+Implement the `SDKLogging` interface and pass your class to the `logging` option:
 
 ```typescript
 import type { SDKLogging } from '@strivacity/sdk-nuxt';
@@ -421,7 +427,6 @@ export class MyLogger implements SDKLogging {
 	xEventId?: string;
 
 	debug(message: string): void {
-		// Send to your logging pipeline
 		console.debug(this.xEventId ? `[${this.xEventId}] ${message}` : message);
 	}
 
@@ -439,172 +444,100 @@ export class MyLogger implements SDKLogging {
 }
 ```
 
-Then register your custom logger in your Nuxt configuration:
-
-```typescript
-import { defineNuxtConfig } from 'nuxt/config';
-import { MyLogger } from './logging/MyLogger';
-
-export default defineNuxtConfig({
-	ssr: false,
-	modules: ['@strivacity/sdk-nuxt'],
-	strivacity: {
-		mode: 'redirect',
-		issuer: 'https://<YOUR_DOMAIN>',
-		scopes: ['openid', 'profile'],
-		clientId: '<YOUR_CLIENT_ID>',
-		redirectUri: '<YOUR_REDIRECT_URI>',
-		logging: MyLogger, // Use your custom logger
-	},
-});
-```
-
-### Logger Interface
+The `SDKLogging` interface requires `debug`, `info`, `warn`, and `error` methods. The optional `xEventId` property, when set by the SDK, provides a correlation ID to trace related log messages across the authentication flow.
 
-The `SDKLogging` interface requires the following methods:
+## API Documentation
 
-- **`debug(message: string): void`** - Log debug-level messages
-- **`info(message: string): void`** - Log informational messages
-- **`warn(message: string): void`** - Log warning messages
-- **`error(message: string, error: Error): void`** - Log error messages with error objects
-
-The optional `xEventId` property, when set by the SDK, provides a correlation ID to trace related log messages across the authentication flow.
-
-### API Documentation
-
-#### `useStrivacity` composable
+### `useStrivacity` composable
 
 ```typescript
 useStrivacity<T extends PopupContext | RedirectContext | NativeContext>(): T;
 ```
 
-You can choose between `PopupContext`, `RedirectContext`, or `NativeContext` using the `mode` option when configuring the SDK.
+The composable returns a different context type depending on the `mode` configured in `nuxt.config.ts`.
 
-**Properties**
+**Shared properties (all modes)**
 
-- **`sdk: RedirectFlow | PopupFlow | NativeFlow`**: Returns the SDK instance based on the configured mode.
-- **`loading: Ref<boolean>`**: Indicates if the session is being loaded.
-- **`options: SDKOptions`**: The configured options for the SDK.
-- **`isAuthenticated: Ref<boolean>`**: Indicates whether the user is authenticated.
-- **`idTokenClaims: Ref<IdTokenClaims | null>`**: Claims from the ID token, or null if not available.
-- **`accessToken: Ref<string | null>`**: The access token, or null if not available.
-- **`refreshToken: Ref<string | null>`**: The refresh token, or null if not available.
-- **`accessTokenExpired: Ref<boolean>`**: Indicates if the access token has expired.
-- **`accessTokenExpirationDate: Ref<number | null>`**: Expiration date of the access token, or null if not set.
+- **`sdk: RedirectFlow | PopupFlow | NativeFlow`**: The underlying SDK flow instance.
+- **`loading: Ref<boolean>`**: `true` while the session is being initialized.
+- **`options: SDKOptions`**: The configured SDK options.
+- **`isAuthenticated: Ref<boolean>`**: `true` when the user has a valid session.
+- **`idTokenClaims: Ref<IdTokenClaims | null>`**: Claims from the ID token, or `null` if not authenticated.
+- **`accessToken: Ref<string | null>`**: The current access token.
+- **`refreshToken: Ref<string | null>`**: The current refresh token.
+- **`accessTokenExpired: Ref<boolean>`**: `true` when the access token has expired.
+- **`accessTokenExpirationDate: Ref<number | null>`**: Expiration timestamp (Unix seconds) of the access token.
 
 ---
 
 **Type: `RedirectContext`**
 
-Represents the available methods for redirect-based interactions.
-
-- **`login(options?: LoginOptions): Promise<void>`**: Initiates the login process by redirecting the user to the identity provider.
-  - `options` (optional): Configuration options for login.
-- **`register(options?: RegisterOptions): Promise<void>`**: Registers a new user using a redirect flow.
-  - `options` (optional): Configuration options for registration.
-- **`refresh(): Promise<void>`**: Refreshes the user's session using a redirect flow.
-- **`revoke(): Promise<void>`**: Revokes the current session tokens using a redirect flow.
-- **`logout(options?: LogoutOptions): Promise<void>`**: Logs out the user by redirecting to the identity provider.
-  - `options` (optional): Configuration options for logout.
-- **`handleCallback(url?: string): Promise<void>`**: Handles the callback after a redirect-based authentication or token exchange.
-  - `url` (optional): The URL to handle for the callback.
+- **`login(options?: LoginOptions): Promise<void>`**: Initiates login by redirecting to the identity provider.
+- **`register(options?: RegisterOptions): Promise<void>`**: Initiates registration using a redirect flow.
+- **`refresh(): Promise<void>`**: Refreshes the user's session.
+- **`revoke(): Promise<void>`**: Revokes the current session tokens.
+- **`logout(options?: LogoutOptions): Promise<void>`**: Logs the user out via redirect.
+- **`handleCallback(url?: string): Promise<void>`**: Processes the authorization callback after redirect.
+- **`entry(): Promise<Record<string, string>>`**: Processes an externally-initiated flow URL and returns the parameters needed to resume the flow.
 
 ---
 
 **Type: `PopupContext`**
 
-Represents the available methods for popup-based interactions.
-
-- **`login(options?: LoginOptions): Promise<void>`**: Initiates the login process using a popup window.
-  - `options` (optional): Configuration options for login.
-- **`register(options?: RegisterOptions): Promise<void>`**: Registers a new user using a popup flow.
-  - `options` (optional): Configuration options for registration.
-- **`refresh(): Promise<void>`**: Refreshes the user's session using a popup.
-- **`revoke(): Promise<void>`**: Revokes the current session tokens using a popup flow.
-- **`logout(options?: LogoutOptions): Promise<void>`**: Logs out the user using a popup window.
-  - `options` (optional): Configuration options for logout.
-- **`handleCallback(url?: string): Promise<void>`**: Handles the callback after a popup-based authentication or token exchange.
-  - `url` (optional): The URL to handle for the callback.
+- **`login(options?: LoginOptions): Promise<void>`**: Initiates login using a popup window.
+- **`register(options?: RegisterOptions): Promise<void>`**: Initiates registration using a popup.
+- **`refresh(): Promise<void>`**: Refreshes the user's session.
+- **`revoke(): Promise<void>`**: Revokes the current session tokens.
+- **`logout(options?: LogoutOptions): Promise<void>`**: Logs the user out via popup.
+- **`handleCallback(url?: string): Promise<void>`**: Processes the authorization callback.
+- **`entry(): Promise<Record<string, string>>`**: Processes an externally-initiated flow URL.
 
 ---
 
 **Type: `NativeContext`**
 
-Represents the available methods for native-based interactions.
-
-- **`login(options?: LoginOptions): Promise<NativeFlowHandler>`**: Initiates the login process using a native flow.
-  - `options` (optional): Configuration options for login.
-- **`register(options?: RegisterOptions): Promise<NativeFlowHandler>`**: Registers a new user using a native flow.
-  - `options` (optional): Configuration options for registration.
+- **`login(options?: LoginOptions): Promise<NativeFlowHandler>`**: Initiates login using the native flow.
+- **`register(options?: RegisterOptions): Promise<NativeFlowHandler>`**: Initiates registration using the native flow.
 - **`refresh(): Promise<void>`**: Refreshes the user's session.
 - **`revoke(): Promise<void>`**: Revokes the current session tokens.
-- **`logout(options?: LogoutOptions): Promise<void>`**: Logs out the user by redirecting to the logout page.
-  - `options` (optional): Configuration options for logout.
-- **`handleCallback(url?: string): Promise<void>`**: Handles the callback after a redirect-based authentication. This will be called automatically by the native flow handler during fallback.
-  - `url` (optional): The URL to handle for the callback.
+- **`logout(options?: LogoutOptions): Promise<void>`**: Logs the user out via redirect.
+- **`handleCallback(url?: string): Promise<void>`**: Processes the authorization callback.
+- **`entry(): Promise<Record<string, string>>`**: Processes an externally-initiated flow URL.
 
-#### `StyLoginRenderer` component
-
-The `StyLoginRenderer` component is used in native mode to render the authentication UI directly within your application. It provides a fully customizable login experience using your own UI components.
-
-```typescript
-StyLoginRenderer: Vue.Component<{
-	params?: NativeParams;
-	widgets?: PartialRecord<WidgetType, Vue.Component>;
-	sessionId?: string | null;
-	onLogin?: (claims?: IdTokenClaims | null) => void;
-	onFallback?: (error: FallbackError) => void;
-	onError?: (error: any) => void;
-	onGlobalMessage?: (message: string) => void;
-	onBlockReady?: ({ previousState, state }: { previousState: LoginFlowState; state: LoginFlowState }) => void;
-}>;
-```
+---
 
-**Properties**
+### `StyLoginRenderer` component
 
-- **`params?: NativeParams`** (optional): Additional parameters to pass to the native login flow. These parameters can include custom configuration options for the authentication process.
+Auto-imported in `native` mode to render the authentication UI with your own widget components.
 
-- **`widgets?: PartialRecord<WidgetType, Vue.Component>`** (optional): A collection of Vue components that define the UI widgets used in the authentication flow. Each widget type (input, button, layout, etc.) can be customized with your own components.
+**Props**
 
-- **`sessionId?: string | null`** (optional): The session ID for continuing an existing authentication session. This is typically extracted from URL parameters when returning from external identity providers.
+- **`params?: NativeParams`**: Additional parameters for the native login flow.
+- **`widgets?: PartialRecord<WidgetType, Vue.Component>`**: Custom Vue components for each widget type used in the flow.
+- **`sessionId?: string | null`**: Session ID for resuming an existing authentication session.
 
 **Events**
 
-- **`@login?: (claims?: IdTokenClaims | null) => void`** (optional): Event emitted when authentication is successful. Receives the ID token claims as a parameter.
-
-- **`@fallback?: (error: FallbackError) => void`** (optional): Event emitted when the native flow cannot handle the authentication and needs to fall back to redirect mode. The error parameter contains the fallback URL.
-
-- **`@error?: (error: any) => void`** (optional): Event emitted when an error occurs during the authentication process. Use this to handle and display error messages to users.
-
-- **`@global-message?: (message: string) => void`** (optional): Event emitted when the authentication flow wants to display a global message to the user (e.g., account lockout warnings, validation messages).
-
-- **`@block-ready?: ({ previousState, state }: { previousState: LoginFlowState; state: LoginFlowState }) => void`** (optional): Event emitted when the authentication flow transitions between states. Useful for tracking progress, implementing custom logging, or injecting analytics. Receives both the previous and current flow states.
+- **`@login`**: Emitted on successful authentication. Receives `IdTokenClaims | null`.
+- **`@fallback`**: Emitted when the native flow needs to fall back to redirect. Receives `FallbackError` with a fallback URL.
+- **`@error`**: Emitted when an error occurs during authentication.
+- **`@global-message`**: Emitted when the flow wants to display a global message (e.g. account lockout warning).
+- **`@block-ready`**: Emitted on flow state transitions. Receives `{ previousState: LoginFlowState; state: LoginFlowState }`. Useful for analytics and custom logging.
 
-**Widget Types**
+## Vulnerability Reporting
 
-The `widgets` prop accepts the following widget types:
+The [Guidelines for responsible disclosure](https://www.strivacity.com/report-a-security-issue) details the procedure for disclosing security issues. Please do not report security vulnerabilities on the public issue tracker.
 
-- `checkbox`: For checkbox input fields
-- `date`: For date input fields
-- `input`: For text input fields
-- `layout`: For layout containers and form structure
-- `loading`: For loading indicators
-- `multiSelect`: For multi-select dropdown fields
-- `passcode`: For passcode input fields
-- `password`: For password input fields
-- `phone`: For phone number input fields
-- `select`: For single-select dropdown fields
-- `static`: For static text and display elements
-- `submit`: For form submission buttons
+## License
 
-Each widget component receives props specific to its type and function within the authentication flow.
+@strivacity/sdk-nuxt is available under the MIT License. See the [LICENSE](https://github.com/Strivacity/sdk-js/blob/main/LICENSE) file for more info.
 
-### Links
+## Contributing
 
-[Example app](https://github.com/Strivacity/sdk-js/tree/main/apps/nuxt)
+Please see our [contributing guide](https://github.com/Strivacity/sdk-js/blob/main/CONTRIBUTING.md).
 
 ## Migrating to v3.0
 
 ### Entry API Major Changes
 
-Strivacity SDK's `entry()` API now returns a structured object instead of a plain string. To see examples of these changes, check the apps folder in this repository.
+Strivacity SDK's `entry()` API now returns a structured object instead of a plain string. Check the example above in the usage section for more details.

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "@strivacity/sdk-nuxt",
   "configKey": "strivacity",
-  "version": "3.0.0-rc.0",
+  "version": "3.0.1",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "3.6.1"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strivacity/sdk-nuxt",
-  "version": "3.0.0-rc.0",
+  "version": "3.0.1",
   "license": "MIT",
   "description": "Strivacity Nuxt SDK client",
   "author": "strivacity <opensource@strivacity.com>",
@@ -10,7 +10,7 @@
   },
   "type": "module",
   "dependencies": {
-    "@strivacity/sdk-core": "3.0.0-rc.0"
+    "@strivacity/sdk-core": "3.0.1"
   },
   "main": "./dist/module.mjs",
   "types": "./dist/types.d.mts",