@securitydept/client 0.3.0-beta.1 → 0.3.0-beta.10

package/dist/web/index.mjs

@@ -1,382 +1,379 @@
-import { S as ClientErrorKind, T as UserRecovery, a as normalizeAbortError, h as createRuntime, i as createCancellationTokenFromAbortSignal, l as fromEventPattern, n as createFetchTransport, o as fromAbortSignal, r as createAbortSignalBridge, s as fromStorageEvent, t as FetchTransportRedirectKind, x as ClientError } from "../fetch-transport-DtnSRWAH.mjs";
-//#region src/web/cross-tab-sync.ts
+import { A as RxEventSubject, H as ClientError, K as UserRecovery, U as ClientErrorKind, h as createAsyncSchedulerWithTimestampProvider, k as RxEventStream } from "../rx-DM6Ouv-m.mjs";
+import { n as PopupServerWindowHandle, o as PopupErrorCode, t as PopupClientWindowHandle } from "../handle-DwMgqe7R.mjs";
+import { $ as notMissingProvider, E as ROUTER_TRAIT_TOKEN, F as POPUP_TRAIT_TOKEN, H as PAGE_LIFECYCLE_TRAIT_TOKEN, I as PopupAttachFailureReason, Q as getSecuritydeptProviderToken, R as throwValidationClientError, T as TIME_TRAIT_TOKEN, V as validateWithSchemaSync, Z as createProviderIfTokenMissing, d as SESSION_STORAGE_TRAIT_TOKEN, f as StorageChangeEventOrigin, l as PERSISTENT_STORAGE_TRAIT_TOKEN, t as createFoundationEnvironment, z as validateTraitInput } from "../create-i5VyYgN6.mjs";
+import { a as createPageLifecycleForNativeWeb, i as createRouterForNativeWeb, n as WebLegacyRouter, o as PageResumeTriggerKind, r as WebNavigationRouter, s as createPageResumeSource, t as NativeWebRouter } from "../router-at5bTdJQ.mjs";
+import { filter, from, fromEventPattern, map, merge, take, timer } from "rxjs";
+import { type } from "arktype";
+//#region src/web/events/from-storage.ts
 /**
-* Create a cross-tab sync listener for a specific localStorage key.
-*
-* The browser `storage` event fires on ALL tabs EXCEPT the one that made the
-* change. This makes it a natural primitive for cross-tab state notification.
-*
-* @example
-* ```ts
-* const sync = createCrossTabSync({
-*   key: "auth:v1",
-*   onSync: ({ newValue }) => {
-*     if (newValue) {
-*       // Another tab updated auth state — reconcile
-*       controller.restoreFromPersistence();
-*     } else {
-*       // Another tab cleared auth state — log out
-*       controller.clearState({ clearPersisted: false });
-*     }
-*   },
-* });
-* // Later:
-* sync.dispose();
-* ```
+* Adapt browser `storage` events into an event stream.
 */
-function createCrossTabSync(options) {
-	const target = options.target ?? globalThis;
-	let syncCount = 0;
-	const subscription = fromStorageEvent({
-		target,
-		callback: (storageEvent) => {
-			if (storageEvent.key !== options.key) return;
-			syncCount++;
-			options.onSync({
-				newValue: storageEvent.newValue,
-				oldValue: storageEvent.oldValue
-			});
-		}
-	});
-	return {
-		dispose() {
-			subscription.unsubscribe();
-		},
-		get syncCount() {
-			return syncCount;
-		}
-	};
+function fromStorageEvent(options) {
+	const { storageEventTarget } = options;
+	return RxEventStream.fromObservableInput(fromEventPattern((handler) => {
+		storageEventTarget.addEventListener("storage", handler);
+	}, (handler) => {
+		storageEventTarget.removeEventListener("storage", handler);
+	}));
 }
 //#endregion
-//#region src/web/page-resume-reconciler.ts
-const PageResumeTriggerKind = {
-	Visibility: "visibility",
-	PageShow: "pageshow",
-	Focus: "focus",
-	Online: "online"
-};
-function createPageResumeReconciler(options) {
-	const throttleMs = options.throttleMs ?? 5e3;
-	const getNow = options.now ?? (() => Date.now());
-	const doc = options.document ?? maybeDocument();
-	const win = options.window ?? maybeWindow();
-	let previousVisibilityState = doc?.visibilityState ?? "visible";
-	let lastReconcileAt = 0;
-	let reconcileCount = 0;
-	let disposed = false;
-	const cleanups = [];
-	const reconcile = (event) => {
-		if (disposed) return;
-		const now = getNow();
-		if (now - lastReconcileAt < throttleMs) return;
-		lastReconcileAt = now;
-		reconcileCount += 1;
-		try {
-			const result = options.onReconcile(event);
-			if (isPromiseLike(result)) result.catch((error) => options.onError?.(error, event));
-		} catch (error) {
-			options.onError?.(error, event);
-		}
+//#region src/web/popup.ts
+const PopupForNativeWebCreateOptionsSchema = type({ window: {
+	open: "Function",
+	addEventListener: "Function",
+	removeEventListener: "Function"
+} });
+const PopupForNativeWebUnavailableProbeSchema = type({ window: "null | undefined" });
+function createPopupForNativeWeb(options) {
+	const { validators, time, ...createOptions } = options;
+	const resolvedCreateOptions = {
+		window: globalThis.window ?? null,
+		...createOptions
 	};
-	if (doc) {
-		const handler = () => {
-			const nextVisibilityState = doc.visibilityState;
-			if (nextVisibilityState === "visible" && previousVisibilityState !== "visible") reconcile({ trigger: PageResumeTriggerKind.Visibility });
-			previousVisibilityState = nextVisibilityState;
-		};
-		doc.addEventListener("visibilitychange", handler);
-		cleanups.push(() => doc.removeEventListener("visibilitychange", handler));
-	}
-	if (win) {
-		const pageshowHandler = (event) => {
-			reconcile({
-				trigger: PageResumeTriggerKind.PageShow,
-				persisted: Boolean(event.persisted)
-			});
-		};
-		const focusHandler = () => {
-			reconcile({ trigger: PageResumeTriggerKind.Focus });
-		};
-		const onlineHandler = () => {
-			reconcile({ trigger: PageResumeTriggerKind.Online });
-		};
-		win.addEventListener("pageshow", pageshowHandler);
-		win.addEventListener("focus", focusHandler);
-		win.addEventListener("online", onlineHandler);
-		cleanups.push(() => win.removeEventListener("pageshow", pageshowHandler));
-		cleanups.push(() => win.removeEventListener("focus", focusHandler));
-		cleanups.push(() => win.removeEventListener("online", onlineHandler));
-	}
+	if (validateWithSchemaSync(PopupForNativeWebUnavailableProbeSchema, resolvedCreateOptions).success) return null;
+	validateTraitInput({
+		value: resolvedCreateOptions,
+		bundledSchema: PopupForNativeWebCreateOptionsSchema,
+		validator: validators?.popup,
+		onInvalid: (failure) => throwValidationClientError({
+			code: "web.popup.invalid_native_web_popup_options",
+			source: "web",
+			messagePrefix: "createPopupForNativeWeb could not validate popupForNativeWebCreateOptions",
+			failure
+		})
+	});
+	const nativeWebWindow = resolvedCreateOptions.window;
 	return {
-		dispose() {
-			if (disposed) return;
-			disposed = true;
-			for (const cleanup of cleanups.splice(0)) cleanup();
+		open(url, openOptions) {
+			return createPopupClientWindowHandleForNativeWeb({
+				url,
+				time,
+				window: nativeWebWindow,
+				...openOptions
+			});
 		},
-		get reconcileCount() {
-			return reconcileCount;
+		attach() {
+			return attachPopupWindowToOpenerForNativeWeb({
+				time,
+				window: nativeWebWindow
+			});
 		}
 	};
 }
-function maybeDocument() {
-	const documentTarget = globalThis.document;
-	return isPageResumeDocumentTarget(documentTarget) ? documentTarget : null;
-}
-function maybeWindow() {
-	const windowTarget = globalThis.window;
-	return isPageResumeWindowTarget(windowTarget) ? windowTarget : null;
-}
-function isPageResumeDocumentTarget(value) {
-	return typeof value === "object" && value !== null && "visibilityState" in value && typeof value.addEventListener === "function" && typeof value.removeEventListener === "function";
-}
-function isPageResumeWindowTarget(value) {
-	return typeof value === "object" && value !== null && typeof value.addEventListener === "function" && typeof value.removeEventListener === "function";
-}
-function isPromiseLike(value) {
-	return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
-}
-//#endregion
-//#region src/web/popup.ts
-/** Stable error codes for popup-related failures. */
-const PopupErrorCode = {
-	Blocked: "popup.blocked",
-	Closed: "popup.closed_by_user",
-	Timeout: "popup.relay_timeout",
-	RelayError: "popup.relay_error",
-	Internal: "popup.internal"
-};
-/**
-* Compute the `features` string for `window.open()`, centered on screen.
-*/
-function computePopupFeatures(options = {}) {
+function computePopupFeatures(options = {}, windowLike = globalThis) {
 	const width = options.width ?? 500;
 	const height = options.height ?? 600;
-	return `width=${width},height=${height},left=${Math.max(0, Math.round(window.screenX + (window.innerWidth - width) / 2))},top=${Math.max(0, Math.round(window.screenY + (window.innerHeight - height) / 2))},popup=yes,toolbar=no,menubar=no`;
+	return `width=${width},height=${height},left=${Math.max(0, Math.round((windowLike.screenX ?? 0) + ((windowLike.innerWidth ?? width) - width) / 2))},top=${Math.max(0, Math.round((windowLike.screenY ?? 0) + ((windowLike.innerHeight ?? height) - height) / 2))},popup=yes,toolbar=no,menubar=no`;
 }
-/**
-* Open a popup window to the given URL.
-*
-* Throws a `ClientError` with code `popup.blocked` if the browser
-* blocks the popup.
-*/
-function openPopupWindow(url, options) {
-	const features = computePopupFeatures(options);
-	const target = options?.target ?? "_blank";
-	const win = window.open(url, target, features);
-	if (!win || win.closed) throw new ClientError({
+function createPopupClientWindowHandleForNativeWeb(options) {
+	const hostWindow = options.window;
+	const features = computePopupFeatures(options, hostWindow);
+	const target = options.target ?? "_blank";
+	const popupWindow = hostWindow.open(options.url, target, features);
+	if (!popupWindow || popupWindow.closed) throw new ClientError({
 		kind: ClientErrorKind.Authorization,
 		code: PopupErrorCode.Blocked,
 		message: "Popup window was blocked by the browser. Please allow popups for this site.",
 		recovery: UserRecovery.Retry,
 		source: "popup"
 	});
-	return { window: win };
-}
-/**
-* Wait for a relay message from a popup callback page.
-*
-* The popup callback page should call `relayPopupCallback()` to post
-* the callback URL back to the opener.
-*
-* Resolves with the callback payload (URL or fragment string).
-* Rejects with a `ClientError` if:
-*   - the popup is closed without relaying (popup.closed_by_user)
-*   - the timeout expires (popup.relay_timeout)
-*   - the relay message contains an error (popup.relay_error)
-*/
-function waitForPopupRelay(options) {
-	const timeoutMs = options.timeoutMs ?? 12e4;
-	const expectedOrigin = options.expectedOrigin ?? window.location.origin;
-	const pollIntervalMs = options.pollIntervalMs ?? 500;
-	return new Promise((resolve, reject) => {
-		let settled = false;
-		let timeoutId;
-		let pollId;
-		function cleanup() {
-			settled = true;
-			clearTimeout(timeoutId);
-			clearInterval(pollId);
-			window.removeEventListener("message", onMessage);
-		}
-		function onMessage(event) {
-			if (settled) return;
-			if (event.origin !== expectedOrigin) return;
-			const data = event.data;
-			if (!data || data.type !== "securitydept:popup_callback") return;
-			cleanup();
-			if (data.error) {
-				reject(new ClientError({
-					kind: ClientErrorKind.Protocol,
-					code: PopupErrorCode.RelayError,
-					message: `Popup callback relay error: ${data.error}`,
-					source: "popup"
-				}));
-				return;
-			}
-			resolve(data.payload);
-		}
-		window.addEventListener("message", onMessage);
-		pollId = setInterval(() => {
-			if (settled) return;
-			if (options.popup.window.closed) {
-				cleanup();
-				reject(new ClientError({
-					kind: ClientErrorKind.Authorization,
-					code: PopupErrorCode.Closed,
-					message: "Popup window was closed before completing the login flow.",
-					recovery: UserRecovery.RestartFlow,
-					source: "popup"
-				}));
-			}
-		}, pollIntervalMs);
-		timeoutId = setTimeout(() => {
-			if (settled) return;
-			cleanup();
-			try {
-				options.popup.window.close();
-			} catch {}
-			reject(new ClientError({
-				kind: ClientErrorKind.Timeout,
-				code: PopupErrorCode.Timeout,
-				message: `Popup login timed out after ${timeoutMs}ms.`,
-				recovery: UserRecovery.Retry,
-				source: "popup"
-			}));
-		}, timeoutMs);
+	const resolvedBaseHref = hostWindow.location?.href ?? "http://localhost";
+	const expectedOrigin = options.expectedOrigin ?? new URL(options.url, resolvedBaseHref).origin;
+	const incoming = RxEventStream.fromObservableInput(fromEventPattern((handler) => {
+		hostWindow.addEventListener("message", handler);
+	}, (handler) => {
+		hostWindow.removeEventListener("message", handler);
+	}).pipe(filter((event) => event.origin === expectedOrigin && event.source === popupWindow), map((event) => event.data)));
+	const outgoing = createPostMessageSubject((message) => {
+		popupWindow.postMessage(message, expectedOrigin);
+	});
+	const closedStream = RxEventStream.fromObservableInput(timer(options.pollIntervalMs ?? 500, options.pollIntervalMs ?? 500, createAsyncSchedulerWithTimestampProvider(options.time)).pipe(filter(() => popupWindow.closed), map(() => true), take(1)));
+	return new PopupClientWindowHandle({
+		close() {
+			popupWindow.close();
+		},
+		messaging: {
+			incoming,
+			outgoing
+		},
+		time: options.time,
+		closedStream
 	});
 }
-/**
-* Relay the popup callback result back to the opener window.
-*
-* Call this function from the popup callback page to send the callback
-* URL/fragment back to the parent window that initiated the popup login.
-*
-* @example
-* ```html
-* <script type="module">
-*   import { relayPopupCallback } from "@securitydept/client/web";
-*   relayPopupCallback({ payload: window.location.href });
-* <\/script>
-* ```
-*/
-function relayPopupCallback(options = {}) {
-	const opener = window.opener;
-	if (!opener) return;
-	const targetOrigin = options.targetOrigin ?? window.location.origin;
-	const message = {
-		type: "securitydept:popup_callback",
-		payload: options.payload ?? window.location.href,
-		error: options.error
+function attachPopupWindowToOpenerForNativeWeb(options) {
+	const currentWindow = options.window;
+	const opener = currentWindow.opener;
+	if (!opener) return {
+		kind: "failure",
+		reason: PopupAttachFailureReason.MissingOpener,
+		error: new ClientError({
+			kind: ClientErrorKind.Configuration,
+			message: "Current page is not attached to a popup opener and cannot attach popup messaging.",
+			recovery: UserRecovery.RestartFlow,
+			source: "popup"
+		})
 	};
-	opener.postMessage(message, targetOrigin);
-	if (options.closeAfterRelay !== false) setTimeout(() => {
-		window.close();
-	}, 0);
-}
-//#endregion
-//#region src/web/runtime.ts
-/**
-* Create a `ClientRuntime` for browser/Web-capable environments.
-*/
-function createWebRuntime(overrides = {}) {
-	const { fetchTransport, transport, ...runtime } = overrides;
-	return createRuntime({
-		...runtime,
-		transport: transport ?? createFetchTransport(fetchTransport)
+	const allowedParentOrigin = currentWindow.location?.origin ?? void 0;
+	if (!allowedParentOrigin) return {
+		kind: "failure",
+		reason: PopupAttachFailureReason.MissingOrigin,
+		error: new ClientError({
+			kind: ClientErrorKind.Configuration,
+			message: "Current page has no origin information and cannot attach popup messaging.",
+			recovery: UserRecovery.RestartFlow,
+			source: "popup"
+		})
+	};
+	const incoming = RxEventStream.fromObservableInput(fromEventPattern((handler) => {
+		currentWindow.addEventListener("message", handler);
+	}, (handler) => {
+		currentWindow.removeEventListener("message", handler);
+	}).pipe(filter((event) => event.origin === allowedParentOrigin && event.source === opener), map((event) => event.data)));
+	const outgoing = createPostMessageSubject((message) => {
+		opener.postMessage(message, allowedParentOrigin);
 	});
+	return {
+		kind: "success",
+		handle: new PopupServerWindowHandle({
+			close() {
+				currentWindow.close();
+			},
+			messaging: {
+				incoming,
+				outgoing
+			}
+		})
+	};
+}
+function createPostMessageSubject(send) {
+	const outgoing = new RxEventSubject();
+	outgoing.subscribe({ next(message) {
+		send(message);
+	} });
+	return outgoing;
 }
 //#endregion
-//#region src/web/visibility.ts
-/** Visibility state snapshot passed to the callback. */
-const VisibilityState = {
-	Visible: "visible",
-	Hidden: "hidden"
-};
-/**
-* Subscribe to browser document visibility changes.
-*
-* Built on {@link fromEventPattern} so it follows the same Subscription
-* contract. Returns a {@link Subscription} handle for cleanup.
-*
-* @example
-* ```ts
-* const sub = fromVisibilityChange({
-*   callback: (state) => {
-*     if (state === VisibilityState.Visible) {
-*       scheduleRefresh();
-*     }
-*   },
-* });
-* // Cleanup:
-* sub.unsubscribe();
-* ```
-*/
-function fromVisibilityChange(options) {
-	const doc = options.document ?? globalThis.document;
-	return fromEventPattern({
-		addHandler: (handler) => {
-			doc.addEventListener("visibilitychange", handler);
+//#region src/web/storage.ts
+const NativeWebStorageLikeSchema = type({
+	getItem: "Function",
+	setItem: "Function",
+	removeItem: "Function"
+});
+const StorageEventTargetSchema = type({
+	addEventListener: "Function",
+	removeEventListener: "Function"
+});
+const StorageForNativeWebCreateOptionsSchema = type({
+	storage: NativeWebStorageLikeSchema,
+	storageEventTarget: StorageEventTargetSchema.or("null").or("undefined"),
+	prefix: "string | undefined",
+	validatorKey: "'persistentStorage' | 'sessionStorage'"
+});
+const StorageForNativeWebUnavailableProbeSchema = type({
+	storage: "null | undefined",
+	storageEventTarget: "unknown",
+	prefix: "string | undefined",
+	validatorKey: "'persistentStorage' | 'sessionStorage'"
+});
+const DEFAULT_PERSISTENT_STORAGE_PREFIX = "securitydept.web.client:";
+const DEFAULT_SESSION_STORAGE_PREFIX = "securitydept.web.client:";
+function createStorageForNativeWeb(options) {
+	const { validators, ...createOptions } = options;
+	const global = globalThis;
+	const resolvedCreateOptions = {
+		storage: options.validatorKey === "persistentStorage" ? global.localStorage ?? null : global.sessionStorage ?? null,
+		...createOptions,
+		storageEventTarget: createOptions.storageEventTarget === void 0 ? typeof global.addEventListener === "function" && typeof global.removeEventListener === "function" ? global : null : createOptions.storageEventTarget,
+		prefix: createOptions.prefix ?? (options.validatorKey === "persistentStorage" ? DEFAULT_PERSISTENT_STORAGE_PREFIX : DEFAULT_SESSION_STORAGE_PREFIX)
+	};
+	if (validateWithSchemaSync(StorageForNativeWebUnavailableProbeSchema, resolvedCreateOptions).success) return null;
+	validateTraitInput({
+		value: resolvedCreateOptions,
+		bundledSchema: StorageForNativeWebCreateOptionsSchema,
+		validator: validators?.[options.validatorKey],
+		onInvalid: (failure) => throwValidationClientError({
+			code: "web.storage.invalid_native_web_storage_options",
+			source: "web",
+			messagePrefix: `createStorageForNativeWeb could not validate ${options.validatorKey}ForNativeWebCreateOptions`,
+			failure
+		})
+	});
+	const storage = resolvedCreateOptions.storage;
+	const prefix = resolvedCreateOptions.prefix;
+	const localStorageEvent = new RxEventSubject();
+	const externalStorageEvent = resolvedCreateOptions.storageEventTarget ? from(fromStorageEvent({ storageEventTarget: resolvedCreateOptions.storageEventTarget })).pipe(filter((event) => (event.storageArea === null || event.storageArea === storage) && (event.key === null || event.key.startsWith(prefix))), map((event) => ({
+		origin: StorageChangeEventOrigin.External,
+		key: event.key === null ? null : event.key.slice(prefix.length),
+		oldValue: event.oldValue,
+		newValue: event.newValue
+	}))) : null;
+	return {
+		storageEvent: RxEventStream.fromObservableInput(externalStorageEvent ? merge(localStorageEvent, externalStorageEvent) : localStorageEvent),
+		get(key) {
+			return storage.getItem(prefix + key);
 		},
-		removeHandler: (handler) => {
-			doc.removeEventListener("visibilitychange", handler);
+		set(key, value) {
+			const storageKey = prefix + key;
+			const oldValue = storage.getItem(storageKey);
+			storage.setItem(storageKey, value);
+			localStorageEvent.next({
+				origin: StorageChangeEventOrigin.Local,
+				key,
+				oldValue,
+				newValue: value
+			});
 		},
-		callback: () => {
-			const state = doc.visibilityState === "visible" ? VisibilityState.Visible : VisibilityState.Hidden;
-			options.callback(state);
+		take(key) {
+			const storageKey = prefix + key;
+			const value = storage.getItem(storageKey);
+			if (value !== null) {
+				storage.removeItem(storageKey);
+				localStorageEvent.next({
+					origin: StorageChangeEventOrigin.Local,
+					key,
+					oldValue: value,
+					newValue: null
+				});
+			}
+			return value;
+		},
+		remove(key) {
+			const storageKey = prefix + key;
+			const oldValue = storage.getItem(storageKey);
+			storage.removeItem(storageKey);
+			if (oldValue !== null) localStorageEvent.next({
+				origin: StorageChangeEventOrigin.Local,
+				key,
+				oldValue,
+				newValue: null
+			});
 		}
+	};
+}
+function createPersistentStorageForNativeWeb(options) {
+	return createStorageForNativeWeb({
+		...options,
+		validatorKey: "persistentStorage"
+	});
+}
+function createSessionStorageForNativeWeb(options) {
+	return createStorageForNativeWeb({
+		...options,
+		validatorKey: "sessionStorage"
 	});
 }
 //#endregion
-//#region src/web/visibility-reconciler.ts
+//#region src/web/environment.ts
+function createEnvironmentForNativeWeb(options) {
+	const userProviders = options.providers ?? [];
+	const providers = [...createNativeWebTraitProviders(options, new Set(userProviders.map((provider) => getSecuritydeptProviderToken(provider)))), ...userProviders];
+	return createFoundationEnvironment({
+		providers,
+		transport: options.transport,
+		transportForStdFetchCreateOptions: options.transportForStdFetchCreateOptions,
+		time: options.time,
+		timeForStdCreateOptions: options.timeForStdCreateOptions,
+		realmStorage: options.realmStorage,
+		idleCallback: options.idleCallback,
+		span: options.span,
+		spanCreateOptions: options.spanCreateOptions,
+		tracing: options.tracing,
+		tracingCreateOptions: options.tracingCreateOptions,
+		validators: options.validators
+	});
+}
+function createNativeWebTraitProviders(options, externalProviderTokens) {
+	return [
+		createProviderIfTokenMissing(externalProviderTokens, ROUTER_TRAIT_TOKEN, () => createNativeWebTraitUnit({
+			provide: ROUTER_TRAIT_TOKEN,
+			value: options.router,
+			createValue: () => createRouterForNativeWeb({
+				...options.routerForNativeWebCreateOptions,
+				validators: options.validators
+			})
+		})),
+		createProviderIfTokenMissing(externalProviderTokens, PAGE_LIFECYCLE_TRAIT_TOKEN, () => createNativeWebTraitUnit({
+			provide: PAGE_LIFECYCLE_TRAIT_TOKEN,
+			value: options.pageLifecycle,
+			createValue: () => createPageLifecycleForNativeWeb({
+				...options.pageLifecycleForNativeWebCreateOptions,
+				validators: options.validators
+			})
+		})),
+		createProviderIfTokenMissing(externalProviderTokens, POPUP_TRAIT_TOKEN, () => createNativeWebTraitUnit({
+			provide: POPUP_TRAIT_TOKEN,
+			value: options.popup,
+			createValue: (time) => createPopupForNativeWeb({
+				time,
+				...options.popupForNativeWebCreateOptions,
+				validators: options.validators
+			}),
+			deps: [TIME_TRAIT_TOKEN]
+		})),
+		createProviderIfTokenMissing(externalProviderTokens, PERSISTENT_STORAGE_TRAIT_TOKEN, () => createNativeWebTraitUnit({
+			provide: PERSISTENT_STORAGE_TRAIT_TOKEN,
+			value: options.persistentStorage,
+			createValue: () => createPersistentStorageForNativeWeb({
+				...options.persistentStorageForNativeWebCreateOptions,
+				validators: options.validators
+			})
+		})),
+		createProviderIfTokenMissing(externalProviderTokens, SESSION_STORAGE_TRAIT_TOKEN, () => createNativeWebTraitUnit({
+			provide: SESSION_STORAGE_TRAIT_TOKEN,
+			value: options.sessionStorage,
+			createValue: () => createSessionStorageForNativeWeb({
+				...options.sessionStorageForNativeWebCreateOptions,
+				validators: options.validators
+			})
+		}))
+	].filter(notMissingProvider);
+}
+function createNativeWebTraitUnit(options) {
+	if (options.value !== void 0) return {
+		provide: options.provide,
+		useValue: options.value
+	};
+	return {
+		provide: options.provide,
+		useFactory: options.createValue,
+		deps: options.deps
+	};
+}
+//#endregion
+//#region src/web/sync/cross-tab-sync.ts
 /**
-* Create a visibility reconciler that triggers a callback when the page
-* transitions from hidden → visible.
+* Create a cross-tab sync listener for a specific localStorage key.
+*
+* The browser `storage` event fires on ALL tabs EXCEPT the one that made the
+* change. This makes it a natural primitive for cross-tab state notification.
 *
 * @example
 * ```ts
-* const reconciler = createVisibilityReconciler({
-*   onReconcile: () => {
-*     // Re-check token freshness or sync cross-tab state
-*     if (controller.snapshot?.tokens.accessTokenExpiresAt) {
-*       scheduleRefreshIfExpired();
+* const subscription = createCrossTabSync({
+*   key: "auth:v1",
+*   storageEventTarget: window,
+* }).subscribe({
+*   next: ({ newValue }) => {
+*     if (newValue) {
+*       // Another tab updated auth state — reconcile
+*       client.restorePersistedState();
+*     } else {
+*       // Another tab cleared auth state — log out
+*       controller.clearState({ persistPolicy: "skip" });
 *     }
 *   },
 * });
 * // Later:
-* reconciler.dispose();
+* subscription.unsubscribe();
 * ```
 */
-function createVisibilityReconciler(options) {
-	const throttleMs = options.throttleMs ?? 5e3;
-	const getNow = options.now ?? (() => Date.now());
-	let lastReconcileAt = 0;
-	let reconcileCount = 0;
-	const doc = options.document ?? globalThis.document;
-	let previousState = doc.visibilityState === "visible" ? VisibilityState.Visible : VisibilityState.Hidden;
-	const subscription = fromVisibilityChange({
-		callback: (state) => {
-			if (state === VisibilityState.Visible && previousState === VisibilityState.Hidden) {
-				const now = getNow();
-				if (now - lastReconcileAt >= throttleMs) {
-					lastReconcileAt = now;
-					reconcileCount++;
-					options.onReconcile();
-				}
-			}
-			previousState = state;
-		},
-		document: doc
-	});
-	return {
-		dispose() {
-			subscription.unsubscribe();
-		},
-		get reconcileCount() {
-			return reconcileCount;
-		}
-	};
+function createCrossTabSync(options) {
+	return RxEventStream.fromObservableInput(fromStorageEvent({ storageEventTarget: options.storageEventTarget })).pipe(filter((storageEvent) => storageEvent.key === options.key), map((storageEvent) => ({
+		newValue: storageEvent.newValue,
+		oldValue: storageEvent.oldValue
+	})));
 }
 //#endregion
-export { FetchTransportRedirectKind, PageResumeTriggerKind, PopupErrorCode, VisibilityState, computePopupFeatures, createAbortSignalBridge, createCancellationTokenFromAbortSignal, createCrossTabSync, createFetchTransport, createPageResumeReconciler, createVisibilityReconciler, createWebRuntime, fromAbortSignal, fromStorageEvent, fromVisibilityChange, normalizeAbortError, openPopupWindow, relayPopupCallback, waitForPopupRelay };
+export { NativeWebRouter, PageResumeTriggerKind, WebLegacyRouter, WebNavigationRouter, computePopupFeatures, createCrossTabSync, createEnvironmentForNativeWeb, createPageLifecycleForNativeWeb, createPageResumeSource, createPersistentStorageForNativeWeb, createPopupForNativeWeb, createRouterForNativeWeb, createSessionStorageForNativeWeb, createStorageForNativeWeb, fromStorageEvent };
 
 //# sourceMappingURL=index.mjs.map