@powerhousedao/reactor-browser 6.2.2-dev.6 → 6.2.2-dev.61

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

@@ -1,42 +1,69 @@
-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-BZabzj4l.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;
+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) {
+	walletActivator = activator;
+}
+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);
 }
 //#endregion
 //#region src/renown/constants.ts
@@ -44,7 +71,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 +92,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 +143,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 +156,13 @@ async function login(userDid, renown) {
 	}
 }
 async function logout() {
+	try {
+		await getActiveWalletController()?.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 +175,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 +202,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 +243,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 +968,88 @@ async function initRenownCrypto() {
 	return await new RenownCryptoBuilder().withKeyPairStorage(keyStorage).build();
 }
 //#endregion
+//#region src/renown/use-renown-session-cookie.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 +1068,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 +1102,226 @@ 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 click, 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);
+	const user = useUser();
+	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 [activated, setActivated] = useState(() => typeof window !== "undefined" && isWalletRedirectReturn(window.location.search, metas));
+	if (user && !activated) setActivated(true);
+	const active = activated;
+	const [adapters, setAdapters] = useState(null);
+	const mountedRef = useRef(/* @__PURE__ */ new Map());
+	const { onSession } = useCompleteRedirectSignIn(metas);
+	useEffect(() => {
+		if (!descriptors) return;
+		setWalletActivator(() => {
+			setActivated(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);
+		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
+export { RENOWN_NETWORK_ID as A, openRenown as C, DOMAIN_TYPE as D, CREDENTIAL_TYPES as E, VERIFIABLE_CREDENTIAL_EIP712_TYPE as M, ISSUER_TYPE as O, logout as S, CREDENTIAL_SUBJECT_TYPE as T, SpinnerIcon as _, useRenownInit as a, useRenownAuthAsync as b, initConnectCrypto as c, RenownUserButton as d, RenownLoginButton as f, RenownLogo as g, DisconnectIcon as h, Renown as i, RENOWN_URL as j, RENOWN_CHAIN_ID as k, initRenownCrypto as l, CopyIcon as m, RenownProvider as n, useRenownSessionCookie as o, ChevronDownIcon as p, RenownWalletProvider as r, useRenownSessionSynced as s, useRenownLoginMethods as t, RenownAuthButton as u, UserIcon as v, CREDENTIAL_SCHEMA_EIP712_TYPE as w, login as x, useRenownAuth as y };
 
-//# sourceMappingURL=renown-D-1c_Bvx.js.map
+//# sourceMappingURL=renown-2nWrFlDw.js.map