@timeback/sdk 0.1.8 → 0.1.10

package/dist/client/adapters/svelte/stores/client.ts

@@ -8,6 +8,8 @@ import { writable } from 'svelte/store'
 
 import { TimebackClient } from '@timeback/sdk/client'
 
+import { isBrowser } from '../../../lib/utils'
+
 import type { Readable } from 'svelte/store'
 
 let clientInstance: TimebackClient | undefined
@@ -24,15 +26,6 @@ function getOrCreateClient(): TimebackClient {
 	return clientInstance
 }
 
-/**
- * Check if we're running in the browser.
- *
- * @returns True if in browser
- */
-function isBrowser(): boolean {
-	return typeof window !== 'undefined'
-}
-
 /**
  * Internal client store.
  */

package/dist/client/adapters/svelte/stores/profile.d.ts

@@ -3,8 +3,8 @@
  *
  * Svelte store for user profile state.
  */
-import type { TimebackProfileState } from '../types';
 import type { Readable } from 'svelte/store';
+import type { TimebackProfileState } from '../types';
 /**
  * Store containing the Timeback profile state.
  *

package/dist/client/adapters/svelte/stores/profile.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"profile.d.ts","sourceRoot":"","sources":["../../../../../src/client/adapters/svelte/stores/profile.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAOH,OAAO,KAAK,EAAE,oBAAoB,EAA6B,MAAM,UAAU,CAAA;AAC/E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AA6E5C;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,oBAAoB,CAAgB,CAAA;AAE3E;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,OAAO,CAAiB,CAAA;AAEvE;;;;;;;;;;;;;GAaG;AACH,wBAAgB,oBAAoB,IAAI,IAAI,CAS3C;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,sBAAsB,IAAI,IAAI,CAS7C"}
+{"version":3,"file":"profile.d.ts","sourceRoot":"","sources":["../../../../../src/client/adapters/svelte/stores/profile.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AASH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAC5C,OAAO,KAAK,EAAE,oBAAoB,EAA6B,MAAM,UAAU,CAAA;AAoE/E;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,oBAAoB,CAAgB,CAAA;AAE3E;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,OAAO,CAAiB,CAAA;AAEvE;;;;;;;;;;;;;GAaG;AACH,wBAAgB,oBAAoB,IAAI,IAAI,CAS3C;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,sBAAsB,IAAI,IAAI,CAS7C"}

package/dist/client/adapters/svelte/stores/profile.ts

@@ -4,27 +4,20 @@
  * Svelte store for user profile state.
  */
 
+import { writable } from 'svelte/store'
+
 import { fetchProfileOnce, getProfileCache } from '../../../lib/user-cache'
+import { isBrowser } from '../../../lib/utils'
 import { getClientInstance } from './client'
-import { writable } from 'svelte/store'
 import { verificationStore } from './verification'
 
-import type { TimebackProfileState, TimebackVerificationState } from '../types'
 import type { Readable } from 'svelte/store'
+import type { TimebackProfileState, TimebackVerificationState } from '../types'
 
 const profileStore = writable<TimebackProfileState>({ status: 'idle' })
 const canFetchStore = writable<boolean>(false)
 let profileInitialized = false
 
-/**
- * Check if we're running in the browser.
- *
- * @returns True if in browser
- */
-function isBrowser(): boolean {
-	return typeof window !== 'undefined'
-}
-
 /**
  * Run the profile fetch.
  *

package/dist/client/adapters/svelte/stores/verification.d.ts

@@ -3,8 +3,8 @@
  *
  * Svelte store for user verification state.
  */
-import type { TimebackVerificationState } from '../types';
 import type { Readable } from 'svelte/store';
+import type { TimebackVerificationState } from '../types';
 export declare const verificationStore: import("svelte/store").Writable<TimebackVerificationState>;
 /**
  * Store containing the Timeback verification state.

package/dist/client/adapters/svelte/stores/verification.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"verification.d.ts","sourceRoot":"","sources":["../../../../../src/client/adapters/svelte/stores/verification.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAOH,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,UAAU,CAAA;AACzD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAc5C,eAAO,MAAM,iBAAiB,4DAA6D,CAAA;AA8D3F;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,yBAAyB,CAAqB,CAAA;AAE1F;;;;;;;;;;;GAWG;AACH,wBAAgB,2BAA2B,IAAI,IAAI,CAGlD"}
+{"version":3,"file":"verification.d.ts","sourceRoot":"","sources":["../../../../../src/client/adapters/svelte/stores/verification.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AASH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAE5C,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,UAAU,CAAA;AAczD,eAAO,MAAM,iBAAiB,4DAA6D,CAAA;AAoI3F;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,yBAAyB,CAAqB,CAAA;AAE1F;;;;;;;;;;;GAWG;AACH,wBAAgB,2BAA2B,IAAI,IAAI,CAGlD"}

package/dist/client/adapters/svelte/stores/verification.ts

@@ -4,13 +4,16 @@
  * Svelte store for user verification state.
  */
 
+import { writable } from 'svelte/store'
+
+import { DEFAULT_RETRY_ATTEMPTS, DEFAULT_RETRY_DELAYS_MS } from '../../../../shared/constants'
 import { getVerifyCache, verifyOnce } from '../../../lib/user-cache'
+import { getRetryDelay, isBrowser, sleep } from '../../../lib/utils'
 import { clientStore, getClientInstance } from './client'
-import { writable } from 'svelte/store'
 
+import type { Readable } from 'svelte/store'
 import type { TimebackVerifyResult } from '../../../../shared/types'
 import type { TimebackVerificationState } from '../types'
-import type { Readable } from 'svelte/store'
 
 /**
  * Convert a verify result into a store-friendly state machine.
@@ -28,16 +31,21 @@ export const verificationStore = writable<TimebackVerificationState>({ status: '
 let verificationInitialized = false
 
 /**
- * Check if we're running in the browser.
+ * Counter tracking the current verification run.
  *
- * @returns True if in browser
+ * Each call to `runVerification` increments this counter and captures
+ * its value. Before updating state, the run checks if it's still current.
+ * This prevents stale results from overwriting fresh ones when multiple
+ * verification attempts overlap (e.g., initial retry + user refresh).
  */
-function isBrowser(): boolean {
-	return typeof window !== 'undefined'
-}
+let currentRunId = 0
 
 /**
- * Run the verification check.
+ * Run the verification check with retry logic.
+ *
+ * Uses a run ID to prevent race conditions when multiple verification
+ * attempts overlap. Each run captures the current ID and only updates
+ * state if it's still the active run.
  *
  * @param force - If true, bypass cache and force a fresh verification
  */
@@ -45,23 +53,79 @@ async function runVerification(force: boolean): Promise<void> {
 	const client = getClientInstance()
 	if (!client) return
 
+	/**
+	 * Capture this run's ID. Any subsequent call to runVerification
+	 * will increment currentRunId, making this run "cancelled".
+	 */
+	const runId = ++currentRunId
+
+	/**
+	 * Check if this run is still the active one.
+	 *
+	 * @returns False if a newer verification run has started
+	 */
+	const isCurrentRun = () => runId === currentRunId
+
 	if (!force) {
 		const cached = getVerifyCache(client)
 		if (cached) {
-			verificationStore.set(toVerificationState(cached))
+			if (isCurrentRun()) {
+				verificationStore.set(toVerificationState(cached))
+			}
 			return
 		}
 	}
 
-	verificationStore.set({ status: 'loading' })
+	if (isCurrentRun()) {
+		verificationStore.set({ status: 'loading' })
+	}
+
+	let lastError: Error | undefined
+
+	for (let attempt = 0; attempt <= DEFAULT_RETRY_ATTEMPTS; attempt++) {
+		if (!isCurrentRun()) return
+
+		/**
+		 * Wait for a calculated delay before retrying the verification request.
+		 *
+		 * This occurs only on subsequent attempts (not the initial try),
+		 * introducing a backoff based on the configured retry delays.
+		 */
+		if (attempt > 0) {
+			const delay = getRetryDelay(DEFAULT_RETRY_DELAYS_MS, attempt - 1)
+			await sleep(delay)
+			if (!isCurrentRun()) return
+		}
+
+		try {
+			const result = await verifyOnce(client, force || attempt > 0)
+
+			if (!isCurrentRun()) return
+
+			verificationStore.set(toVerificationState(result))
+
+			return
+		} catch (err) {
+			lastError = err instanceof Error ? err : new Error('Failed to verify Timeback user')
+			/**
+			 * An error occurred during this verification attempt.
+			 * Proceeding to the next retry attempt if any remain.
+			 *
+			 * The last encountered error is saved for potential error state handling.
+			 */
+		}
+	}
 
-	try {
-		const result = await verifyOnce(client, force)
-		verificationStore.set(toVerificationState(result))
-	} catch (err) {
+	/**
+	 * All verification attempts have failed after exhausting
+	 * the configured retry policy. The verification state will
+	 * transition to "error" if this run is still current, and the last
+	 * encountered error message (if available) will be presented to the consumer.
+	 */
+	if (isCurrentRun() && lastError) {
 		verificationStore.set({
 			status: 'error',
-			message: err instanceof Error ? err.message : 'Failed to verify Timeback user',
+			message: lastError.message,
 		})
 	}
 }
@@ -73,7 +137,17 @@ function initVerification(): void {
 	if (verificationInitialized) return
 	verificationInitialized = true
 
-	// Subscribe to client changes to auto-verify
+	/**
+	 * Subscribes to changes in the Timeback client store.
+	 *
+	 * Any time the client instance becomes available or changes,
+	 * automatically triggers a verification attempt to ensure the
+	 * user's Timeback verification status is kept up-to-date.
+	 *
+	 * This enables responsive status updates when authentication
+	 * state changes or when the client instance is re-initialized,
+	 * providing a seamless verification experience in Svelte apps.
+	 */
 	clientStore.subscribe(client => {
 		if (client && isBrowser()) {
 			void runVerification(false)
@@ -81,7 +155,6 @@ function initVerification(): void {
 	})
 }
 
-// Auto-init in browser
 if (isBrowser()) {
 	initVerification()
 }

package/dist/client/adapters/svelte/types.d.ts

@@ -3,33 +3,5 @@
  *
  * Types for Svelte-specific stores.
  */
-import type { TimebackProfile } from '../../../shared/types';
-/**
- * Verification state for the current user.
- */
-export type TimebackVerificationState = {
-    status: 'loading';
-} | {
-    status: 'verified';
-    timebackId: string;
-} | {
-    status: 'unverified';
-} | {
-    status: 'error';
-    message: string;
-};
-/**
- * Profile state for the current user.
- */
-export type TimebackProfileState = {
-    status: 'idle';
-} | {
-    status: 'loading';
-} | {
-    status: 'loaded';
-    profile: TimebackProfile;
-} | {
-    status: 'error';
-    message: string;
-};
+export type { TimebackProfileState, TimebackVerificationState } from '../../../shared/types';
 //# sourceMappingURL=types.d.ts.map

package/dist/client/adapters/svelte/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/client/adapters/svelte/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA;AAE5D;;GAEG;AACH,MAAM,MAAM,yBAAyB,GAClC;IAAE,MAAM,EAAE,SAAS,CAAA;CAAE,GACrB;IAAE,MAAM,EAAE,UAAU,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,GAC1C;IAAE,MAAM,EAAE,YAAY,CAAA;CAAE,GACxB;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAA;AAEvC;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAC7B;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,GAClB;IAAE,MAAM,EAAE,SAAS,CAAA;CAAE,GACrB;IAAE,MAAM,EAAE,QAAQ,CAAC;IAAC,OAAO,EAAE,eAAe,CAAA;CAAE,GAC9C;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAA"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/client/adapters/svelte/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,YAAY,EAAE,oBAAoB,EAAE,yBAAyB,EAAE,MAAM,uBAAuB,CAAA"}

package/dist/client/adapters/vue/composables/useTimebackVerification.d.ts

@@ -14,8 +14,10 @@ import type { TimebackVerificationState, UseTimebackVerificationOptions } from '
  * The composable runs automatically once the Timeback client is available, and
  * provides a `refresh()` method to retry.
  *
+ * By default, the composable retries failed verification attempts with exponential
+ * backoff to handle race conditions (e.g., user not yet created in backend).
+ *
  * @param options - Composable options
- * @param options.enabled - If false, the composable does nothing and stays in loading state.
  * @returns Verification state and a refresh method
  *
  * @example

package/dist/client/adapters/vue/composables/useTimebackVerification.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useTimebackVerification.d.ts","sourceRoot":"","sources":["../../../../../src/client/adapters/vue/composables/useTimebackVerification.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAOH,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,KAAK,CAAA;AAE9B,OAAO,KAAK,EAAE,yBAAyB,EAAE,8BAA8B,EAAE,MAAM,UAAU,CAAA;AAczF;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,uBAAuB,CACtC,OAAO,GAAE,8BAAmC,GAC1C;IACF,KAAK,EAAE,GAAG,CAAC,yBAAyB,CAAC,CAAA;IACrC,OAAO,EAAE,MAAM,IAAI,CAAA;CACnB,CA+DA"}
+{"version":3,"file":"useTimebackVerification.d.ts","sourceRoot":"","sources":["../../../../../src/client/adapters/vue/composables/useTimebackVerification.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AASH,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,KAAK,CAAA;AAE9B,OAAO,KAAK,EAAE,yBAAyB,EAAE,8BAA8B,EAAE,MAAM,UAAU,CAAA;AAczF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,GAAE,8BAAmC,GAAG;IACtF,KAAK,EAAE,GAAG,CAAC,yBAAyB,CAAC,CAAA;IACrC,OAAO,EAAE,MAAM,IAAI,CAAA;CACnB,CAsGA"}

package/dist/client/adapters/vue/composables/useTimebackVerification.ts

@@ -9,7 +9,9 @@
 
 import { ref, watch } from 'vue'
 
+import { DEFAULT_RETRY_ATTEMPTS, DEFAULT_RETRY_DELAYS_MS } from '../../../../shared/constants'
 import { getVerifyCache, verifyOnce } from '../../../lib/user-cache'
+import { getRetryDelay, sleep } from '../../../lib/utils'
 import { useTimeback } from '../provider'
 
 import type { Ref } from 'vue'
@@ -34,8 +36,10 @@ function toState(result: TimebackVerifyResult): TimebackVerificationState {
  * The composable runs automatically once the Timeback client is available, and
  * provides a `refresh()` method to retry.
  *
+ * By default, the composable retries failed verification attempts with exponential
+ * backoff to handle race conditions (e.g., user not yet created in backend).
+ *
  * @param options - Composable options
- * @param options.enabled - If false, the composable does nothing and stays in loading state.
  * @returns Verification state and a refresh method
  *
  * @example
@@ -57,16 +61,18 @@ function toState(result: TimebackVerifyResult): TimebackVerificationState {
  * </template>
  * ```
  */
-export function useTimebackVerification(
-	options: UseTimebackVerificationOptions = {},
-): {
+export function useTimebackVerification(options: UseTimebackVerificationOptions = {}): {
 	state: Ref<TimebackVerificationState>
 	refresh: () => void
 } {
 	const enabled = options.enabled ?? true
+	const retryAttempts = options.retryAttempts ?? DEFAULT_RETRY_ATTEMPTS
+	const retryDelays = options.retryDelays ?? DEFAULT_RETRY_DELAYS_MS
 	const timebackRef = useTimeback()
 
-	const state = ref<TimebackVerificationState>({ status: 'loading' }) as Ref<TimebackVerificationState>
+	const state = ref<TimebackVerificationState>({
+		status: 'loading',
+	}) as Ref<TimebackVerificationState>
 	const refreshNonce = ref(0)
 
 	let lastHandledRefreshNonce = 0
@@ -100,24 +106,59 @@ export function useTimebackVerification(
 
 			state.value = { status: 'loading' }
 
-			try {
-				if (!timeback) return
+			if (!timeback) return
 
-				if (force) {
-					lastHandledRefreshNonce = nonce
-				}
+			if (force) {
+				lastHandledRefreshNonce = nonce
+			}
 
-				const result = await verifyOnce(timeback, force)
+			let lastError: Error | undefined
 
+			for (let attempt = 0; attempt <= retryAttempts; attempt++) {
 				if (cancelled) return
 
-				state.value = toState(result)
-			} catch (err) {
-				if (!cancelled) {
-					state.value = {
-						status: 'error',
-						message: err instanceof Error ? err.message : 'Failed to verify Timeback user',
-					}
+				/**
+				 * Wait for a calculated delay before retrying the verification request.
+				 *
+				 * This occurs only on subsequent attempts (not the initial try),
+				 * introducing a backoff based on the configured retry delays.
+				 */
+				if (attempt > 0) {
+					const delay = getRetryDelay(retryDelays, attempt - 1)
+					await sleep(delay)
+					if (cancelled) return
+				}
+
+				try {
+					const result = await verifyOnce(timeback, force || attempt > 0)
+
+					if (cancelled) return
+
+					state.value = toState(result)
+
+					return
+				} catch (err) {
+					lastError =
+						err instanceof Error ? err : new Error('Failed to verify Timeback user')
+					/**
+					 * An error occurred during this verification attempt.
+					 * Proceeding to the next retry attempt if any remain.
+					 *
+					 * The last encountered error is saved for potential error state handling.
+					 */
+				}
+			}
+
+			/**
+			 * All verification attempts have failed after exhausting
+			 * the configured retry policy. The verification state will
+			 * transition to "error" if not cancelled, and the last encountered
+			 * error message (if available) will be presented to the consumer.
+			 */
+			if (!cancelled && lastError) {
+				state.value = {
+					status: 'error',
+					message: lastError.message,
 				}
 			}
 		},

package/dist/client/adapters/vue/provider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../../../src/client/adapters/vue/provider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAGrD,OAAO,KAAK,EAAgB,QAAQ,EAAE,UAAU,EAAE,MAAM,KAAK,CAAA;AAqC7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,eAAO,MAAM,gBAAgB;IAG3B,wFAAwF;;;;;;;;IAAxF,wFAAwF;;;;;;;0FAoBxF,CAAA;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,WAAW,IAAI,UAAU,CAAC,cAAc,GAAG,SAAS,CAAC,CAQpE"}
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../../../src/client/adapters/vue/provider.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAIrD,OAAO,KAAK,EAAgB,QAAQ,EAAE,UAAU,EAAE,MAAM,KAAK,CAAA;AA2B7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,eAAO,MAAM,gBAAgB;IAG3B,wFAAwF;;;;;;;;IAAxF,wFAAwF;;;;;;;0FAoBxF,CAAA;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,WAAW,IAAI,UAAU,CAAC,cAAc,GAAG,SAAS,CAAC,CAQpE"}

package/dist/client/adapters/vue/provider.ts

@@ -1,6 +1,9 @@
-import { TimebackClient } from '@timeback/sdk/client'
 import { defineComponent, inject, onMounted, provide, shallowRef } from 'vue'
 
+import { TimebackClient } from '@timeback/sdk/client'
+
+import { isBrowser } from '../../lib/utils'
+
 import type { InjectionKey, PropType, ShallowRef } from 'vue'
 
 /**
@@ -14,16 +17,6 @@ import type { InjectionKey, PropType, ShallowRef } from 'vue'
  */
 const TimebackKey: InjectionKey<ShallowRef<TimebackClient | undefined>> = Symbol('timeback')
 
-/**
- * Check if we're running in the browser.
- *
- * @returns True if in browser
- */
-function isBrowser(): boolean {
-	return typeof window !== 'undefined'
-}
-
-// Singleton client instance for browser
 let clientInstance: TimebackClient | undefined
 
 /**

package/dist/client/adapters/vue/types.d.ts

@@ -3,35 +3,8 @@
  *
  * Types for Vue-specific composables.
  */
-import type { TimebackProfile } from '../../../shared/types';
-/**
- * Verification state for the current user.
- */
-export type TimebackVerificationState = {
-    status: 'loading';
-} | {
-    status: 'verified';
-    timebackId: string;
-} | {
-    status: 'unverified';
-} | {
-    status: 'error';
-    message: string;
-};
-/**
- * Profile state for the current user.
- */
-export type TimebackProfileState = {
-    status: 'idle';
-} | {
-    status: 'loading';
-} | {
-    status: 'loaded';
-    profile: TimebackProfile;
-} | {
-    status: 'error';
-    message: string;
-};
+import type { TimebackProfileState, TimebackVerificationState } from '../../../shared/types';
+export type { TimebackProfileState, TimebackVerificationState } from '../../../shared/types';
 /**
  * Options for the useTimebackVerification composable.
  */
@@ -39,9 +12,32 @@ export interface UseTimebackVerificationOptions {
     /**
      * If false, the composable does nothing and stays in loading state.
      *
+     * Use this to delay verification until prerequisites are met
+     * (e.g., user exists in your database).
+     *
      * @default true
      */
     enabled?: boolean;
+    /**
+     * Number of retry attempts on failure.
+     *
+     * This helps handle race conditions where the user may not be
+     * fully set up in the backend when verification first runs.
+     *
+     * Set to 0 to disable retries.
+     *
+     * @default 3
+     */
+    retryAttempts?: number;
+    /**
+     * Delay in ms before each retry attempt.
+     *
+     * Can be a single number (same delay for all retries) or an array
+     * of delays for each attempt (e.g., [100, 300, 1000] for exponential backoff).
+     *
+     * @default [100, 300, 1000]
+     */
+    retryDelays?: number | readonly number[];
 }
 /**
  * Return value of the useTimebackVerification composable.

package/dist/client/adapters/vue/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/client/adapters/vue/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA;AAE5D;;GAEG;AACH,MAAM,MAAM,yBAAyB,GAClC;IAAE,MAAM,EAAE,SAAS,CAAA;CAAE,GACrB;IAAE,MAAM,EAAE,UAAU,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,GAC1C;IAAE,MAAM,EAAE,YAAY,CAAA;CAAE,GACxB;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAA;AAEvC;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAC7B;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,GAClB;IAAE,MAAM,EAAE,SAAS,CAAA;CAAE,GACrB;IAAE,MAAM,EAAE,QAAQ,CAAC;IAAC,OAAO,EAAE,eAAe,CAAA;CAAE,GAC9C;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAA;AAEvC;;GAEG;AACH,MAAM,WAAW,8BAA8B;IAC9C;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,6BAA6B;IAC7C,gDAAgD;IAChD,KAAK,EAAE,yBAAyB,CAAA;IAEhC,qDAAqD;IACrD,OAAO,EAAE,MAAM,IAAI,CAAA;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACzC;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;IAEjB;;;;;OAKG;IACH,IAAI,CAAC,EAAE,OAAO,CAAA;CACd;AAED;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACxC,2CAA2C;IAC3C,KAAK,EAAE,oBAAoB,CAAA;IAE3B,gFAAgF;IAChF,QAAQ,EAAE,OAAO,CAAA;IAEjB,oEAAoE;IACpE,YAAY,EAAE,MAAM,IAAI,CAAA;IAExB,2EAA2E;IAC3E,OAAO,EAAE,MAAM,IAAI,CAAA;CACnB"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/client/adapters/vue/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,yBAAyB,EAAE,MAAM,uBAAuB,CAAA;AAE5F,YAAY,EAAE,oBAAoB,EAAE,yBAAyB,EAAE,MAAM,uBAAuB,CAAA;AAE5F;;GAEG;AACH,MAAM,WAAW,8BAA8B;IAC9C;;;;;;;OAOG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;IAEjB;;;;;;;;;OASG;IACH,aAAa,CAAC,EAAE,MAAM,CAAA;IAEtB;;;;;;;OAOG;IACH,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,CAAA;CACxC;AAED;;GAEG;AACH,MAAM,WAAW,6BAA6B;IAC7C,gDAAgD;IAChD,KAAK,EAAE,yBAAyB,CAAA;IAEhC,qDAAqD;IACrD,OAAO,EAAE,MAAM,IAAI,CAAA;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACzC;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;IAEjB;;;;;OAKG;IACH,IAAI,CAAC,EAAE,OAAO,CAAA;CACd;AAED;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACxC,2CAA2C;IAC3C,KAAK,EAAE,oBAAoB,CAAA;IAE3B,gFAAgF;IAChF,QAAQ,EAAE,OAAO,CAAA;IAEjB,oEAAoE;IACpE,YAAY,EAAE,MAAM,IAAI,CAAA;IAExB,2EAA2E;IAC3E,OAAO,EAAE,MAAM,IAAI,CAAA;CACnB"}

package/dist/client/adapters/vue/types.ts

@@ -4,25 +4,9 @@
  * Types for Vue-specific composables.
  */
 
-import type { TimebackProfile } from '../../../shared/types'
+import type { TimebackProfileState, TimebackVerificationState } from '../../../shared/types'
 
-/**
- * Verification state for the current user.
- */
-export type TimebackVerificationState =
-	| { status: 'loading' }
-	| { status: 'verified'; timebackId: string }
-	| { status: 'unverified' }
-	| { status: 'error'; message: string }
-
-/**
- * Profile state for the current user.
- */
-export type TimebackProfileState =
-	| { status: 'idle' }
-	| { status: 'loading' }
-	| { status: 'loaded'; profile: TimebackProfile }
-	| { status: 'error'; message: string }
+export type { TimebackProfileState, TimebackVerificationState } from '../../../shared/types'
 
 /**
  * Options for the useTimebackVerification composable.
@@ -31,9 +15,34 @@ export interface UseTimebackVerificationOptions {
 	/**
 	 * If false, the composable does nothing and stays in loading state.
 	 *
+	 * Use this to delay verification until prerequisites are met
+	 * (e.g., user exists in your database).
+	 *
 	 * @default true
 	 */
 	enabled?: boolean
+
+	/**
+	 * Number of retry attempts on failure.
+	 *
+	 * This helps handle race conditions where the user may not be
+	 * fully set up in the backend when verification first runs.
+	 *
+	 * Set to 0 to disable retries.
+	 *
+	 * @default 3
+	 */
+	retryAttempts?: number
+
+	/**
+	 * Delay in ms before each retry attempt.
+	 *
+	 * Can be a single number (same delay for all retries) or an array
+	 * of delays for each attempt (e.g., [100, 300, 1000] for exponential backoff).
+	 *
+	 * @default [100, 300, 1000]
+	 */
+	retryDelays?: number | readonly number[]
 }
 
 /**

package/dist/client/auth/types.d.ts

@@ -1,7 +1,7 @@
 /**
  * Client Auth Types
  *
- * Small, framework-agnostic extension point for customizing how the SDK makes HTTP requests.
+ * Extension point for customizing how the SDK makes HTTP requests.
  */
 export type TimebackFetch = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
 /**

package/dist/client/index.d.ts

@@ -1,7 +1,7 @@
 /**
  * Client Module
  *
- * Framework-agnostic client exports.
+ * Client exports.
  */
 export { createClient } from './timeback-client';
 export { TimebackClient } from './timeback-client.class';