@powerhousedao/reactor-browser 6.2.2-dev.8 → 6.2.2-dev.80

package/dist/{renown-D-1c_Bvx.js → renown-BIEv6bSI.js}

@@ -1,42 +1,105 @@
-import { t as makePHEventFunctions } from "./make-ph-event-functions-BHoLPif5.js";
+import { a as useRenown, c as RENOWN_INITIAL_UNKNOWN, i as useLoginStatus, l as RenownInitialUserProvider, n as setRenown, o as useUser, s as RENOWN_INITIAL_ANONYMOUS, t as addRenownEventHandler, u as useRenownInitialAuth } from "./renown-BHxwP7xU.js";
 import { logger } from "document-model";
-import { Children, cloneElement, forwardRef, isValidElement, useCallback, useEffect, useRef, useState, useSyncExternalStore } from "react";
-import { BrowserKeyStorage, CREDENTIAL_SCHEMA_EIP712_TYPE, CREDENTIAL_SUBJECT_TYPE, CREDENTIAL_TYPES, DOMAIN_TYPE, ISSUER_TYPE, RenownBuilder, RenownCryptoBuilder, VERIFIABLE_CREDENTIAL_EIP712_TYPE } from "@renown/sdk";
+import { Children, cloneElement, createContext, forwardRef, isValidElement, useCallback, useContext, useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
-//#region src/hooks/loading.ts
-const { useValue: useLoading, setValue: setLoading, addEventHandler: addLoadingEventHandler } = makePHEventFunctions("loading");
-const loading = null;
-//#endregion
-//#region src/hooks/renown.ts
-const renownEventFunctions = makePHEventFunctions("renown");
-/** Adds an event handler for the renown instance */
-const addRenownEventHandler = renownEventFunctions.addEventHandler;
-/** Returns the renown instance */
-const useRenown = renownEventFunctions.useValue;
-/** Sets the renown instance */
-const setRenown = renownEventFunctions.setValue;
-/** Returns the DID from the renown instance */
-function useDid() {
-	return useRenown()?.did;
-}
-/** Returns the current user from the renown instance, subscribing to user events */
-function useUser() {
-	const renown = useRenown();
-	const [user, setUser] = useState(renown?.user);
-	useEffect(() => {
-		setUser(renown?.user);
-		if (!renown) return;
-		return renown.on("user", setUser);
-	}, [renown]);
-	return user;
-}
-/** Returns the login status, subscribing to renown status events */
-function useLoginStatus() {
-	const renown = useRenown();
-	return useSyncExternalStore((cb) => {
-		if (!renown) return () => {};
-		return renown.on("status", cb);
-	}, () => renown === null ? "loading" : renown?.status, () => void 0);
+import { BrowserKeyStorage, CREDENTIAL_SCHEMA_EIP712_TYPE, CREDENTIAL_SUBJECT_TYPE, CREDENTIAL_TYPES, DOMAIN_TYPE, ISSUER_TYPE, MissingSwitchboardError, RenownBuilder, RenownCryptoBuilder, VERIFIABLE_CREDENTIAL_EIP712_TYPE, readPersistedUser } from "@renown/sdk";
+import { LoginMethod, isWalletRedirectReturn, resolveAdapters } from "@renown/sdk/wallet";
+//#region src/renown/wallet-registry.ts
+let activeWalletController;
+let controllerWaiters = [];
+let walletActivator;
+const activatorListeners = /* @__PURE__ */ new Set();
+function setActiveWalletController(controller) {
+	activeWalletController = controller;
+	if (controller) {
+		const waiters = controllerWaiters;
+		controllerWaiters = [];
+		waiters.forEach(({ resolve }) => resolve(controller));
+	}
+}
+function failWalletActivation(error) {
+	const waiters = controllerWaiters;
+	controllerWaiters = [];
+	waiters.forEach(({ reject }) => reject(error));
+}
+function getActiveWalletController() {
+	return activeWalletController;
+}
+function setWalletActivator(activator) {
+	if (activator === walletActivator) return;
+	walletActivator = activator;
+	activatorListeners.forEach((listener) => listener());
+}
+function subscribeWalletActivator(listener) {
+	activatorListeners.add(listener);
+	return () => activatorListeners.delete(listener);
+}
+function getWalletActivator() {
+	return walletActivator;
+}
+function whenWalletControllerReady() {
+	if (activeWalletController) return Promise.resolve(activeWalletController);
+	return new Promise((resolve, reject) => controllerWaiters.push({
+		resolve,
+		reject
+	}));
+}
+const NO_DESCRIPTORS = Object.freeze([]);
+const DESCRIPTOR_STORE = Symbol.for("@powerhousedao/reactor-browser:renown-wallet-descriptors");
+function descriptorStore() {
+	const host = globalThis;
+	return host[DESCRIPTOR_STORE] ??= {
+		descriptors: NO_DESCRIPTORS,
+		listeners: /* @__PURE__ */ new Set()
+	};
+}
+function setWalletDescriptors(descriptors) {
+	const store = descriptorStore();
+	const next = descriptors ?? NO_DESCRIPTORS;
+	if (next === store.descriptors) return;
+	if (next.length === 0 && store.descriptors.length === 0) return;
+	store.descriptors = next;
+	store.listeners.forEach((listener) => listener());
+}
+function getWalletDescriptors() {
+	return descriptorStore().descriptors;
+}
+function getServerWalletDescriptors() {
+	return NO_DESCRIPTORS;
+}
+function subscribeWalletDescriptors(listener) {
+	const { listeners } = descriptorStore();
+	listeners.add(listener);
+	return () => listeners.delete(listener);
+}
+const NO_CONTROLLERS = Object.freeze({});
+const CONTROLLER_STORE = Symbol.for("@powerhousedao/reactor-browser:renown-wallet-adapter-controllers");
+function controllerStore() {
+	const host = globalThis;
+	return host[CONTROLLER_STORE] ??= {
+		controllers: NO_CONTROLLERS,
+		listeners: /* @__PURE__ */ new Set()
+	};
+}
+function setWalletAdapterController(id, controller) {
+	const store = controllerStore();
+	if (store.controllers[id] === controller) return;
+	const next = { ...store.controllers };
+	if (controller) next[id] = controller;
+	else delete next[id];
+	store.controllers = Object.freeze(next);
+	store.listeners.forEach((listener) => listener());
+}
+function getWalletAdapterControllers() {
+	return controllerStore().controllers;
+}
+function getServerWalletAdapterControllers() {
+	return NO_CONTROLLERS;
+}
+function subscribeWalletAdapterControllers(listener) {
+	const { listeners } = controllerStore();
+	listeners.add(listener);
+	return () => listeners.delete(listener);
 }
 //#endregion
 //#region src/renown/constants.ts
@@ -44,7 +107,7 @@ const RENOWN_URL = "https://www.renown.id";
 const RENOWN_NETWORK_ID = "eip155";
 const RENOWN_CHAIN_ID = "1";
 //#endregion
-//#region src/renown/utils.ts
+//#region src/renown/session.ts
 function openRenown(documentId) {
 	const renown = window.ph?.renown;
 	let renownUrl = renown?.baseUrl;
@@ -65,10 +128,47 @@ function openRenown(documentId) {
 	url.searchParams.set("returnUrl", returnUrl.toJSON());
 	window.open(url, "_self")?.focus();
 }
-/**
-* Reads the `?user=` DID from the URL if present.
-* Returns the DID and cleans up the URL parameter.
-*/
+async function signIn(session) {
+	const renown = window.ph?.renown;
+	if (!renown) {
+		logger.warn("Renown instance not found, cannot sign in");
+		return;
+	}
+	return renown.signIn({
+		address: session.address,
+		chainId: session.chainId,
+		signTypedData: session.signTypedData
+	});
+}
+let inFlightSignIn;
+let inFlightAddress;
+let lastSignedAddress;
+async function completeSignIn(session) {
+	const { address } = session;
+	if (address === lastSignedAddress) return;
+	if (inFlightSignIn && address === inFlightAddress) return inFlightSignIn;
+	inFlightAddress = address;
+	inFlightSignIn = (async () => {
+		try {
+			const user = await signIn(session);
+			if (user) lastSignedAddress = address;
+			return user;
+		} finally {
+			inFlightSignIn = void 0;
+			inFlightAddress = void 0;
+		}
+	})();
+	return inFlightSignIn;
+}
+function resetSignInGuard() {
+	inFlightSignIn = void 0;
+	inFlightAddress = void 0;
+	lastSignedAddress = void 0;
+}
+function hasRedirectSignIn() {
+	if (typeof window === "undefined") return false;
+	return new URLSearchParams(window.location.search).has("user");
+}
 function consumeDidFromUrl() {
 	if (typeof window === "undefined") return;
 	const userParam = new URLSearchParams(window.location.search).get("user");
@@ -79,12 +179,6 @@ function consumeDidFromUrl() {
 	window.history.replaceState({}, "", cleanUrl.toString());
 	return userDid;
 }
-/**
-* Log in the user. Resolves the user DID from (in order):
-* 1. Explicit `userDid` argument
-* 2. `?user=` URL parameter (from Renown portal redirect)
-* 3. Previously stored session in the Renown instance
-*/
 async function login(userDid, renown) {
 	if (!renown) return;
 	const did = userDid ?? consumeDidFromUrl();
@@ -98,7 +192,13 @@ async function login(userDid, renown) {
 	}
 }
 async function logout() {
+	try {
+		await (getActiveWalletController() ?? await getWalletActivator()?.())?.disconnect();
+	} catch (error) {
+		logger.error(error instanceof Error ? error.message : String(error));
+	}
 	await (window.ph?.renown)?.logout();
+	resetSignInGuard();
 	const url = new URL(window.location.href);
 	if (url.searchParams.has("user")) {
 		url.searchParams.delete("user");
@@ -111,13 +211,20 @@ function truncateAddress$1(address) {
 	if (address.length <= 13) return address;
 	return `${address.slice(0, 7)}...${address.slice(-5)}`;
 }
+function isUserCancellation(error) {
+	const msg = error.message.toLowerCase();
+	return msg.includes("exited_auth_flow") || msg.includes("user rejected") || msg.includes("user denied") || msg.includes("userrejected") || msg.includes("cancel");
+}
 function toRenownAuthStatus(loginStatus, user) {
 	if (loginStatus === "authorized") return user ? "authorized" : "checking";
 	return loginStatus;
 }
 function useRenownAuth() {
 	const user = useUser();
-	const status = toRenownAuthStatus(useLoginStatus(), user);
+	const loginStatus = useLoginStatus();
+	const [pending, setPending] = useState(false);
+	const [error, setError] = useState(void 0);
+	const status = toRenownAuthStatus(loginStatus, user);
 	const address = user?.address;
 	const ensName = user?.ens?.name;
 	const avatarUrl = user?.profile?.userImage ?? user?.ens?.avatarUrl;
@@ -131,9 +238,39 @@ function useRenownAuth() {
 		profileId,
 		displayName: ensName ?? user?.profile?.username ?? void 0,
 		displayAddress: address ? truncateAddress$1(address) : void 0,
-		login: useCallback(() => {
-			openRenown();
+		login: useCallback((session, method) => {
+			const existing = getActiveWalletController();
+			const activator = getWalletActivator();
+			if (!session && !existing && !activator) {
+				openRenown();
+				return;
+			}
+			setPending(true);
+			setError(void 0);
+			(async () => {
+				try {
+					let resolved = session;
+					if (!resolved) {
+						const activated = existing ?? (activator ? await activator() : void 0);
+						resolved = await (getActiveWalletController() ?? activated)?.connect(method);
+					}
+					if (!resolved) {
+						openRenown();
+						return;
+					}
+					await completeSignIn(resolved);
+				} catch (e) {
+					const err = e instanceof Error ? e : new Error(String(e));
+					if (isUserCancellation(err)) return;
+					setError(err);
+					if (MissingSwitchboardError.is(err)) openRenown();
+				} finally {
+					setPending(false);
+				}
+			})();
 		}, []),
+		pending,
+		error,
 		logout: useCallback(async () => {
 			await logout();
 		}, []),
@@ -142,6 +279,24 @@ function useRenownAuth() {
 		}, [profileId])
 	};
 }
+const subscribeNothing$1 = () => () => {};
+function useRenownAuthAsync() {
+	const auth = useRenownAuth();
+	const initial = useRenownInitialAuth();
+	const redirectSignIn = useSyncExternalStore(subscribeNothing$1, hasRedirectSignIn, () => false);
+	const { user, status, pending } = auth;
+	let state;
+	if (user) state = "authenticated";
+	else if (pending) state = "resolving";
+	else if (initial.state === "anonymous" && !redirectSignIn && status !== "checking") state = "unauthenticated";
+	else if (status === void 0 || status === "loading" || status === "checking") state = "resolving";
+	else state = "unauthenticated";
+	return {
+		...auth,
+		state,
+		isResolving: state === "resolving"
+	};
+}
 //#endregion
 //#region src/renown/components/icons.tsx
 function RenownLogo({ width = 71, height = 19, hovered = false, color = "currentColor", className }) {
@@ -849,13 +1004,88 @@ async function initRenownCrypto() {
 	return await new RenownCryptoBuilder().withKeyPairStorage(keyStorage).build();
 }
 //#endregion
+//#region src/renown/use-renown-session.ts
+const DEFAULT_ENDPOINT = "/api/renown/session";
+const DEFAULT_EXPIRES_IN = 10080 * 60;
+function useRenownSessionCookie(options = {}) {
+	const endpoint = options.endpoint ?? DEFAULT_ENDPOINT;
+	const expiresIn = options.expiresIn ?? DEFAULT_EXPIRES_IN;
+	const enabled = options.enabled ?? true;
+	const { user, displayName, avatarUrl } = useRenownAuth();
+	const renown = useRenown();
+	const address = user?.address;
+	const profile = user?.profile;
+	const hadUser = useRef(false);
+	const [synced, setSynced] = useState(false);
+	useEffect(() => {
+		if (!enabled) return;
+		const ready = !!renown && typeof renown.getBearerToken === "function";
+		if (address && ready) {
+			hadUser.current = true;
+			setSynced(false);
+			let cancelled = false;
+			(async () => {
+				try {
+					const token = await renown.getBearerToken({ expiresIn });
+					await fetch(endpoint, {
+						method: "POST",
+						headers: { "content-type": "application/json" },
+						body: JSON.stringify({
+							token,
+							profile: {
+								name: displayName ?? null,
+								avatar: avatarUrl ?? null,
+								documentId: profile?.documentId ?? null,
+								username: profile?.username ?? null,
+								userImage: profile?.userImage ?? null
+							}
+						})
+					});
+					if (!cancelled) setSynced(true);
+				} catch (error) {
+					console.error("Failed to sync Renown session cookie", error);
+				}
+			})();
+			return () => {
+				cancelled = true;
+			};
+		}
+		if (!address) {
+			setSynced(false);
+			if (hadUser.current) {
+				hadUser.current = false;
+				fetch(endpoint, { method: "DELETE" }).catch(() => {});
+			}
+		}
+	}, [
+		address,
+		displayName,
+		avatarUrl,
+		profile?.documentId,
+		profile?.username,
+		profile?.userImage,
+		renown,
+		endpoint,
+		expiresIn,
+		enabled
+	]);
+	return { synced };
+}
+const RenownSessionSyncedContext = createContext(false);
+function useRenownSessionSynced() {
+	return useContext(RenownSessionSyncedContext);
+}
+//#endregion
 //#region src/renown/use-renown-init.ts
-async function initRenown(appName, namespace, url) {
+async function initRenown(appName, namespace, url, switchboardUrl, revalidate, chainId) {
 	addRenownEventHandler();
 	setRenown(null);
 	const renown = await new RenownBuilder(appName, {
 		basename: namespace,
-		baseUrl: url
+		baseUrl: url,
+		switchboardUrl,
+		revalidate,
+		chainId
 	}).build();
 	setRenown(renown);
 	await login(void 0, renown);
@@ -874,14 +1104,14 @@ async function initRenown(appName, namespace, url) {
 * }
 * ```
 */
-function useRenownInit({ appName, namespace, url }) {
+function useRenownInit({ appName, namespace, url, switchboardUrl, revalidate = "always", chainId }) {
 	const promiseRef = useRef(null);
 	promiseRef.current ??= Promise.withResolvers();
 	const initRef = useRef(false);
 	useEffect(() => {
 		if (initRef.current) return;
 		initRef.current = true;
-		initRenown(appName, namespace, url).then(promiseRef.current.resolve).catch(promiseRef.current.reject);
+		initRenown(appName, namespace, url, switchboardUrl, revalidate, chainId).then(promiseRef.current.resolve).catch(promiseRef.current.reject);
 	}, []);
 	return promiseRef.current.promise;
 }
@@ -908,6 +1138,242 @@ function Renown({ onError, ...initOptions }) {
 	return null;
 }
 //#endregion
-export { useLoginStatus as A, RENOWN_CHAIN_ID as C, addRenownEventHandler as D, VERIFIABLE_CREDENTIAL_EIP712_TYPE as E, setLoading as F, useLoading as I, useUser as M, addLoadingEventHandler as N, setRenown as O, loading as P, ISSUER_TYPE as S, RENOWN_URL as T, openRenown as _, RenownAuthButton as a, CREDENTIAL_TYPES as b, ChevronDownIcon as c, RenownLogo as d, SpinnerIcon as f, logout as g, login as h, initRenownCrypto as i, useRenown as j, useDid as k, CopyIcon as l, useRenownAuth as m, useRenownInit as n, RenownUserButton as o, UserIcon as p, initConnectCrypto as r, RenownLoginButton as s, Renown as t, DisconnectIcon as u, CREDENTIAL_SCHEMA_EIP712_TYPE as v, RENOWN_NETWORK_ID as w, DOMAIN_TYPE as x, CREDENTIAL_SUBJECT_TYPE as y };
+//#region src/renown/use-complete-redirect-sign-in.ts
+function useCompleteRedirectSignIn(metas) {
+	const renown = useRenown();
+	const user = useUser();
+	const [pendingSilentSession, setPendingSilentSession] = useState(null);
+	const oauthReturnRef = useRef(typeof window !== "undefined" && isWalletRedirectReturn(window.location.search, metas));
+	const onSession = useCallback((_id, session) => {
+		setPendingSilentSession(session?.canSignSilently ? session : null);
+	}, []);
+	useEffect(() => {
+		if (!oauthReturnRef.current) return;
+		if (user) {
+			oauthReturnRef.current = false;
+			return;
+		}
+		if (!pendingSilentSession || !renown) return;
+		oauthReturnRef.current = false;
+		Promise.resolve(completeSignIn(pendingSilentSession)).catch((error) => logger.error(error instanceof Error ? error.message : String(error)));
+	}, [
+		pendingSilentSession,
+		renown,
+		user
+	]);
+	return { onSession };
+}
+//#endregion
+//#region src/renown/wallet-provider.tsx
+function mergeControllers(mounted) {
+	if (mounted.length === 0) return void 0;
+	return {
+		connect(method) {
+			if (method) {
+				const target = mounted.find((m) => m.meta.supportedMethods.includes(method));
+				if (!target) throw new Error(`No wallet adapter supports login method "${method}"`);
+				return target.controller.connect(method);
+			}
+			const chosen = mounted.at(0);
+			if (!chosen) throw new Error("No wallet adapter available");
+			return chosen.controller.connect(method);
+		},
+		async disconnect() {
+			await Promise.all(mounted.map((m) => m.controller.disconnect()));
+		},
+		getSession() {
+			for (const { controller } of mounted) {
+				const session = controller.getSession();
+				if (session) return session;
+			}
+		}
+	};
+}
+function AdapterControllerBridge(props) {
+	const { adapter, onController, onSession } = props;
+	const { meta } = adapter;
+	const controller = adapter.useController();
+	useEffect(() => {
+		onController(meta, controller);
+		return () => onController(meta, void 0);
+	}, [
+		meta,
+		controller,
+		onController
+	]);
+	useEffect(() => {
+		if (!controller.subscribe) return;
+		return controller.subscribe((session) => onSession(meta.id, session));
+	}, [
+		meta.id,
+		controller,
+		onSession
+	]);
+	return null;
+}
+/** Drop-in provider for Renown in-page wallet sign-in: registers the login activator, lazy-mounts the configured adapters on first demand (login, logout, {@link useRenownWalletAdapter}, or an OAuth redirect return — not on a restored session), and merges their controllers for {@link useRenownAuth}. Full walkthrough + examples: the `@powerhousedao/reactor-browser` README ("Renown in-page sign-in") and the Academy Renown authentication guide. Pair with {@link useRenownLoginMethods} to build the login UI. */
+function RenownWalletProvider({ adapters: adaptersConfig, theme, children }) {
+	const [descriptors] = useState(() => adaptersConfig);
+	useEffect(() => {
+		if (typeof process !== "undefined" && true) return;
+		if (adaptersConfig === descriptors) return;
+		console.error("RenownWalletProvider: the `adapters` array changed identity after mount, and the new value was ignored. Build it once at module scope (or memoize it) — see the @powerhousedao/reactor-browser README.");
+	}, [adaptersConfig, descriptors]);
+	useEffect(() => {
+		setWalletDescriptors(descriptors);
+		return () => setWalletDescriptors(void 0);
+	}, [descriptors]);
+	const metas = useMemo(() => descriptors?.map((descriptor) => descriptor.meta) ?? [], [descriptors]);
+	const [active, setActive] = useState(() => typeof window !== "undefined" && isWalletRedirectReturn(window.location.search, metas));
+	const [adapters, setAdapters] = useState(null);
+	const mountedRef = useRef(/* @__PURE__ */ new Map());
+	const { onSession } = useCompleteRedirectSignIn(metas);
+	useEffect(() => {
+		if (!descriptors) return;
+		setWalletActivator(() => {
+			setActive(true);
+			return whenWalletControllerReady();
+		});
+		return () => setWalletActivator(void 0);
+	}, [descriptors]);
+	useEffect(() => {
+		if (!active || !descriptors) return;
+		let cancelled = false;
+		resolveAdapters(descriptors).then((resolved) => {
+			if (cancelled) return;
+			if (resolved.length === 0) {
+				failWalletActivation(/* @__PURE__ */ new Error("No wallet adapters were configured for in-page sign-in."));
+				return;
+			}
+			setAdapters(resolved);
+		}).catch((error) => {
+			if (!cancelled) failWalletActivation(error instanceof Error ? error : new Error(String(error)));
+		});
+		return () => {
+			cancelled = true;
+		};
+	}, [active, descriptors]);
+	const onController = useCallback((meta, controller) => {
+		if (controller) mountedRef.current.set(meta.id, {
+			meta,
+			controller
+		});
+		else mountedRef.current.delete(meta.id);
+		setWalletAdapterController(meta.id, controller);
+		setActiveWalletController(mergeControllers(Array.from(mountedRef.current.values())));
+	}, []);
+	return /* @__PURE__ */ jsxs(Fragment, { children: [children, descriptors && active && adapters && adapters.length > 0 ? adapters.reduceRight((acc, adapter) => {
+		const Provider = adapter.Provider;
+		return /* @__PURE__ */ jsx(Provider, {
+			theme,
+			children: acc
+		});
+	}, /* @__PURE__ */ jsx(Fragment, { children: adapters.map((adapter) => /* @__PURE__ */ jsx(AdapterControllerBridge, {
+		adapter,
+		onController,
+		onSession
+	}, adapter.meta.id)) })) : null] });
+}
+//#endregion
+//#region src/renown/provider.tsx
+const subscribeNothing = () => () => {};
+function SessionSync({ enabled, endpoint, children }) {
+	const { synced } = useRenownSessionCookie({
+		endpoint,
+		enabled
+	});
+	return /* @__PURE__ */ jsx(RenownSessionSyncedContext.Provider, {
+		value: synced,
+		children
+	});
+}
+function RenownProvider({ appName, namespace, url, switchboardUrl, adapters, theme, revalidate, chainId, session, sessionEndpoint, onError, children }) {
+	const isServerSession = session !== void 0;
+	const mounted = useSyncExternalStore(subscribeNothing, () => true, () => false);
+	const seed = useMemo(() => {
+		if (mounted) {
+			const persisted = readPersistedUser(namespace);
+			return persisted ? {
+				state: "authenticated",
+				user: persisted
+			} : RENOWN_INITIAL_ANONYMOUS;
+		}
+		if (!isServerSession) return RENOWN_INITIAL_UNKNOWN;
+		return session?.user ? {
+			state: "authenticated",
+			user: session.user
+		} : RENOWN_INITIAL_ANONYMOUS;
+	}, [
+		mounted,
+		isServerSession,
+		session,
+		namespace
+	]);
+	return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(Renown, {
+		appName,
+		namespace,
+		url,
+		switchboardUrl,
+		revalidate,
+		chainId,
+		onError
+	}), /* @__PURE__ */ jsx(RenownInitialUserProvider, {
+		initialAuth: seed,
+		children: /* @__PURE__ */ jsx(RenownWalletProvider, {
+			adapters,
+			theme,
+			children: /* @__PURE__ */ jsx(SessionSync, {
+				enabled: isServerSession,
+				endpoint: sessionEndpoint,
+				children
+			})
+		})
+	})] });
+}
+//#endregion
+//#region src/renown/login-methods.ts
+const DEFAULT_METHOD_LABELS = {
+	[LoginMethod.WALLET]: "Connect a Wallet",
+	[LoginMethod.GOOGLE]: "Continue with Google",
+	[LoginMethod.EMAIL]: "Continue with Email",
+	[LoginMethod.APPLE]: "Continue with Apple"
+};
+/** The login methods the mounted {@link RenownWalletProvider}'s adapters offer, for building a login UI. Reads each descriptor's eager metadata only — no wallet libraries load. Buttons follow the provider's descriptor array order, deduped; empty when no provider is mounted (redirect-only). Wire each to `useRenownAuth().login(undefined, id)`. Labels are overridable. See the reactor-browser README + Academy Renown auth guide. */
+function useRenownLoginMethods(labels) {
+	const descriptors = useSyncExternalStore(subscribeWalletDescriptors, getWalletDescriptors, getServerWalletDescriptors);
+	return useMemo(() => {
+		const seen = /* @__PURE__ */ new Set();
+		const methods = [];
+		for (const { meta } of descriptors) for (const id of meta.supportedMethods) {
+			if (seen.has(id)) continue;
+			seen.add(id);
+			methods.push({
+				id,
+				label: labels?.[id] ?? DEFAULT_METHOD_LABELS[id] ?? id
+			});
+		}
+		return methods;
+	}, [descriptors, labels]);
+}
+//#endregion
+//#region src/renown/use-renown-wallet-adapter.ts
+/** The controller of one adapter mounted by {@link RenownWalletProvider}, by its `meta.id`, typed as that adapter's own surface — e.g. `useRenownWalletAdapter<PrivyWalletController>("privy")` for headless email OTP. Rendering it activates the wallet tree (the adapter's library loads then), so call it from the sign-in screen, not the app shell. `undefined` until the adapter is mounted, or forever when no provider offers that id. */
+function useRenownWalletAdapter(id) {
+	const controller = useSyncExternalStore(subscribeWalletAdapterControllers, getWalletAdapterControllers, getServerWalletAdapterControllers)[id];
+	const hasActivator = useSyncExternalStore(subscribeWalletActivator, getWalletActivator, () => void 0) !== void 0;
+	useEffect(() => {
+		if (controller || !hasActivator) return;
+		const current = getWalletActivator();
+		if (!current) return;
+		current().catch((error) => logger.error(error instanceof Error ? error.message : String(error)));
+	}, [
+		controller,
+		hasActivator,
+		id
+	]);
+	return controller;
+}
+//#endregion
+export { RENOWN_CHAIN_ID as A, logout as C, CREDENTIAL_TYPES as D, CREDENTIAL_SUBJECT_TYPE as E, RENOWN_URL as M, VERIFIABLE_CREDENTIAL_EIP712_TYPE as N, DOMAIN_TYPE as O, login as S, CREDENTIAL_SCHEMA_EIP712_TYPE as T, RenownLogo as _, Renown as a, useRenownAuth as b, useRenownSessionSynced as c, RenownAuthButton as d, RenownUserButton as f, DisconnectIcon as g, CopyIcon as h, RenownWalletProvider as i, RENOWN_NETWORK_ID as j, ISSUER_TYPE as k, initConnectCrypto as l, ChevronDownIcon as m, useRenownLoginMethods as n, useRenownInit as o, RenownLoginButton as p, RenownProvider as r, useRenownSessionCookie as s, useRenownWalletAdapter as t, initRenownCrypto as u, SpinnerIcon as v, openRenown as w, useRenownAuthAsync as x, UserIcon as y };
 
-//# sourceMappingURL=renown-D-1c_Bvx.js.map
+//# sourceMappingURL=renown-BIEv6bSI.js.map