@flow-industries/id 0.22.1 → 0.23.0

package/dist/sdk/client/profile-button.js

@@ -1,208 +1,145 @@
 import { resolveIdHost } from "../id-host";
 import { getFlow, requireFlow } from "./create-flow";
-import { answerTokenRequest, bridgeToWindow, hostIdentity, makeIframe, OVERLAY_STYLE, sendBridgeNotification, } from "./iframe-host";
-import { setOverlayFocus } from "./overlay-focus";
 const POSITION_STYLE = {
     "top-right": { top: "0", right: "0" },
     "top-left": { top: "0", left: "0" },
     "bottom-right": { bottom: "0", right: "0" },
     "bottom-left": { bottom: "0", left: "0" },
 };
-/**
- * Mounts the universal Flow ID "profile button" — a persistent inline iframe
- * showing the signed-in user's avatar + username (the collapsed pill). Clicking
- * it opens the profile dialog in a SEPARATE fullscreen overlay iframe, so the
- * pill stays in place behind the dialog's dimmed backdrop rather than morphing
- * into it. Both iframes ride the dialog SPA at `${host}/dialog/` (routes
- * `/dialog/profile-pill` and `/dialog/profile`) so the chrome matches the auth
- * dialog and the widget is first-party to Flow ID (reads `/api/me`, uploads
- * avatars with the cookie session).
- *
- * Resolves the Flow singleton automatically (createFlow() must have run), so
- * callers don't thread the instance through. No-op under SSR.
- */
+/** Mount a native account button that opens Flow ID in a normal browser tab. */
 export function createProfileButton(options) {
     if (!("document" in globalThis))
         return { setTheme() { }, destroy() { } };
     const flow = options.flow ?? getFlow() ?? requireFlow();
     const host = resolveIdHost(options.host ?? flow.host);
-    const hostOrigin = new URL(host).origin;
-    // Mutable so `setTheme` recolors over the open bridge, and so a dialog opened
-    // after a toggle is initialized with the theme the host is actually showing.
-    let theme = options.theme ?? "light dark";
-    let createdContainer = null;
-    let container = options.container ?? null;
-    if (!container) {
-        const el = document.createElement("div");
-        Object.assign(el.style, {
+    const createdContainer = options.container
+        ? null
+        : document.createElement("div");
+    const container = options.container ?? createdContainer;
+    if (!container)
+        return { setTheme() { }, destroy() { } };
+    if (createdContainer) {
+        Object.assign(createdContainer.style, {
             position: "fixed",
             zIndex: "2147483000",
-            // Never steal input from the host (e.g. the Godot canvas) — only the
-            // iframe re-enables pointer events for itself.
-            pointerEvents: "none",
             padding: options.padding ?? "1.5rem",
             ...POSITION_STYLE[options.position ?? "top-right"],
         });
-        document.body.appendChild(el);
-        createdContainer = el;
-        container = el;
-    }
-    function makeFrame(title) {
-        const frame = makeIframe(`${host}/dialog/`, title);
-        frame.dataset.flowProfile = "";
-        frame.style.display = "block";
-        return frame;
-    }
-    // A page may host several same-origin Flow iframes (this pill, this dialog,
-    // the auth login dialog). Origin filtering can't tell them apart, so each
-    // bridge is bound to its own iframe window — otherwise their `ready`/`close`
-    // handshakes would cross-fire. Identity is pinned to the host origin so the
-    // username is never broadcast with "*".
-    function makeBridge(frame, route) {
-        const bridge = bridgeToWindow(frame.contentWindow, {
-            targetOrigin: hostOrigin,
-        });
-        sendBridgeNotification(bridge, "__internal", {
-            type: "init",
-            mode: "iframe",
-            referrer: { title: document.title },
-            theme: { colorScheme: theme },
-            route,
-        });
-        return bridge;
-    }
-    // ----- the persistent pill (stays mounted; sizes to its own content) -----
-    const pill = makeFrame("Flow ID profile button");
-    let pillWidth = 0;
-    let pillHeight = 0;
-    function applyPillSize() {
-        Object.assign(pill.style, {
-            position: "static",
-            width: `${pillWidth}px`,
-            height: `${pillHeight}px`,
-            pointerEvents: pillWidth > 0 ? "auto" : "none",
-        });
+        document.body.appendChild(createdContainer);
     }
-    applyPillSize();
-    container.appendChild(pill);
-    const pillBridge = makeBridge(pill, "/dialog/profile-pill");
-    pillBridge.on("__internal", (payload) => {
-        if (payload.type === "profile-resize") {
-            pillWidth = payload.width;
-            pillHeight = payload.height;
-            applyPillSize();
-        }
-        else if (payload.type === "profile-expand") {
-            showDialog();
-        }
-        else if (payload.type === "profile-token-request") {
-            void answerTokenRequest(pillBridge, flow, payload.id);
-        }
+    const button = document.createElement("button");
+    button.type = "button";
+    button.dataset.flowProfile = "";
+    Object.assign(button.style, {
+        display: "flex",
+        alignItems: "center",
+        gap: "8px",
+        border: "1px solid color-mix(in srgb, currentColor 18%, transparent)",
+        borderRadius: "999px",
+        padding: "10px 16px",
+        background: "Canvas",
+        color: "CanvasText",
+        font: "inherit",
+        cursor: "pointer",
+        pointerEvents: "auto",
+        maxWidth: "240px",
+        overflow: "hidden",
+        textOverflow: "ellipsis",
+        whiteSpace: "nowrap",
     });
-    // ----- the dialog overlay (lazy; a separate fullscreen iframe layered ABOVE
-    // the pill, so the pill shows through its dimmed backdrop) -----
-    let dialog = null;
-    let dialogBridge = null;
-    function ensureDialog() {
-        if (dialog)
+    const notice = document.createElement("span");
+    notice.setAttribute("role", "status");
+    Object.assign(notice.style, {
+        display: "block",
+        font: "12px sans-serif",
+        maxWidth: "240px",
+    });
+    const avatar = document.createElement("span");
+    Object.assign(avatar.style, {
+        display: "flex",
+        alignItems: "center",
+        justifyContent: "center",
+        width: "28px",
+        height: "28px",
+        borderRadius: "50%",
+        overflow: "hidden",
+        background: "color-mix(in srgb, currentColor 10%, transparent)",
+        flexShrink: "0",
+    });
+    const name = document.createElement("span");
+    button.append(avatar, name);
+    const fallback = document.createElement("a");
+    fallback.href = `${host}/account`;
+    fallback.target = "_blank";
+    fallback.rel = "noopener noreferrer";
+    fallback.textContent = "Open Flow ID";
+    fallback.hidden = true;
+    let lastUsername;
+    let profileRequest = null;
+    function update() {
+        const user = flow.getState().user;
+        name.textContent = user?.username ?? "Flow ID";
+        button.setAttribute("aria-label", `Open ${user?.username ?? "your"} Flow ID account in a new tab`);
+        if (user?.username === lastUsername)
             return;
-        dialog = makeFrame("Flow ID profile");
-        dialog.inert = true;
-        Object.assign(dialog.style, OVERLAY_STYLE, {
-            pointerEvents: "none",
-        });
-        document.body.appendChild(dialog);
-        dialogBridge = makeBridge(dialog, "/dialog/profile");
-        dialogBridge.on("close", () => hideDialog());
-        dialogBridge.on("__internal", (payload) => {
-            if (payload.type === "profile-login") {
-                hideDialog();
-                void flow
-                    .login(payload.mode === "signup" ? { signUp: true } : { signIn: true })
-                    .catch(() => { });
-            }
-            else if (payload.type === "profile-logout") {
-                hideDialog();
-                void flow.logout().catch(() => { });
-            }
-            else if (payload.type === "profile-token-request") {
-                if (dialogBridge)
-                    void answerTokenRequest(dialogBridge, flow, payload.id);
-            }
-        });
-        sendBridgeNotification(dialogBridge, "__internal", {
-            type: "profile-identity",
-            identity: hostIdentity(flow),
-        });
-    }
-    // The dialog owns its open/close animation entirely; the host only signals
-    // visibility and toggles hit-testing. The overlay iframe is NEVER set to
-    // display:none — that pauses the iframe's requestAnimationFrame, so motion's
-    // engine is asleep when the next open fires and the animation jumps straight
-    // to its end (instant). Keeping it always-rendered, transparent and
-    // click-through while hidden keeps every open/close animation reliable.
-    function showDialog() {
-        ensureDialog();
-        if (!dialog)
+        lastUsername = user?.username;
+        profileRequest?.abort();
+        avatar.textContent = user?.username.slice(0, 1).toUpperCase() ?? "F";
+        if (!user || user.isGuest)
             return;
-        dialog.style.pointerEvents = "auto";
-        setOverlayFocus(dialog, true);
-        sendBridgeNotification(dialogBridge, "__internal", {
-            type: "dialog-shown",
-        });
+        const controller = new AbortController();
+        profileRequest = controller;
+        void fetch(`${host}/api/users/${encodeURIComponent(user.username)}`, {
+            signal: controller.signal,
+            credentials: "omit",
+        })
+            .then(async (response) => {
+            if (!response.ok)
+                return;
+            // SAFETY: Flow ID owns the public profile endpoint and its optional image field.
+            const profile = (await response.json());
+            if (controller.signal.aborted || !profile.image)
+                return;
+            const image = document.createElement("img");
+            image.src = profile.image;
+            image.alt = "";
+            Object.assign(image.style, {
+                width: "100%",
+                height: "100%",
+                objectFit: "cover",
+            });
+            avatar.replaceChildren(image);
+        })
+            .catch(() => { });
     }
-    function hideDialog() {
-        if (!dialog)
-            return;
-        dialog.style.pointerEvents = "none";
-        setOverlayFocus(dialog, false);
-        sendBridgeNotification(dialogBridge, "__internal", {
-            type: "dialog-hidden",
-        });
+    button.addEventListener("click", () => {
+        const opened = flow.openAccount();
+        notice.textContent = opened
+            ? ""
+            : "Your browser blocked the new tab. Open Flow ID below to sign in.";
+        fallback.hidden = opened;
+    });
+    function refresh() {
+        lastUsername = undefined;
+        update();
     }
-    // ----- keep both iframes' identity in sync with the Flow session -----
-    // flow.subscribe fires on any store change (jwt/credential/address too), so
-    // skip re-sending an identical identity (e.g. on every silent JWT refresh).
-    let lastIdentityKey;
-    function pushIdentity() {
-        const identity = hostIdentity(flow);
-        const key = identity ? `${identity.username}|${identity.isGuest}` : "none";
-        if (key === lastIdentityKey)
-            return;
-        lastIdentityKey = key;
-        sendBridgeNotification(pillBridge, "__internal", {
-            type: "profile-identity",
-            identity,
-        });
-        if (dialogBridge)
-            sendBridgeNotification(dialogBridge, "__internal", {
-                type: "profile-identity",
-                identity,
-            });
+    window.addEventListener("focus", refresh);
+    function setTheme(theme) {
+        button.style.colorScheme = theme;
     }
-    pushIdentity();
-    const unsubscribe = flow.subscribe(pushIdentity);
+    setTheme(options.theme ?? "light dark");
+    container.append(button, notice, fallback);
+    update();
+    const unsubscribe = flow.subscribe(update);
     return {
-        setTheme(next) {
-            if (next === theme)
-                return;
-            theme = next;
-            sendBridgeNotification(pillBridge, "__internal", {
-                type: "set-theme",
-                theme: { colorScheme: next },
-            });
-            sendBridgeNotification(dialogBridge, "__internal", {
-                type: "set-theme",
-                theme: { colorScheme: next },
-            });
-        },
+        setTheme,
         destroy() {
-            hideDialog();
             unsubscribe();
-            pillBridge.destroy();
-            dialogBridge?.destroy();
-            pill.remove();
-            dialog?.remove();
+            profileRequest?.abort();
+            window.removeEventListener("focus", refresh);
+            fallback.remove();
+            button.remove();
+            notice.remove();
             createdContainer?.remove();
         },
     };

package/dist/sdk/client/session.d.ts

@@ -1,4 +1,4 @@
-import type { Address, FlowCredential, FlowState, RunLoginParams, RunLoginResult, Store } from "../types";
+import type { Address, FlowCredential, FlowState, Store } from "../types";
 /**
  * Reads the active credential from IndexedDB and seeds the in-memory store
  * with `{ credential, address }`. Run on every page load so signing operations
@@ -9,15 +9,6 @@ import type { Address, FlowCredential, FlowState, RunLoginParams, RunLoginResult
  * not an error.
  */
 export declare function restoreCredential(store: Store<FlowState>): Promise<void>;
-/**
- * Drives the interactive `wallet_connect` flow through the dialog and
- * commits the result to local state.
- *
- * Capabilities are intent only (signUp / signIn / signInHeadless / extras like
- * accessKeyHash). Remembering "which account did this user use last" is
- * the dialog's job — the client doesn't track or pass credentialIds.
- */
-export declare function runLogin(params: RunLoginParams): Promise<RunLoginResult>;
 /**
  * Clears local-only auth state: active credential in IDB, the access key for
  * the current address (if any), and the in-memory store. Does NOT touch the

package/dist/sdk/client/session.js

@@ -2,7 +2,6 @@ import * as OxAddress from "ox/Address";
 import * as PublicKey from "ox/PublicKey";
 import { hex0x } from "../hex";
 import { idb } from "./idb";
-import { METHODS } from "./methods";
 import { initialFlowState } from "./store";
 const CREDENTIAL_KEY = "flow.activeCredential";
 /**
@@ -21,42 +20,6 @@ export async function restoreCredential(store) {
     const address = credentialToAddress(credential);
     store.setState({ credential, address });
 }
-/**
- * Drives the interactive `wallet_connect` flow through the dialog and
- * commits the result to local state.
- *
- * Capabilities are intent only (signUp / signIn / signInHeadless / extras like
- * accessKeyHash). Remembering "which account did this user use last" is
- * the dialog's job — the client doesn't track or pass credentialIds.
- */
-export async function runLogin(params) {
-    const { dialog, store, options, extraCapabilities } = params;
-    const signUp = Boolean(options?.signUp);
-    const capabilities = {
-        createAccount: signUp ? true : undefined,
-        signIn: !signUp && options?.signIn ? true : undefined,
-        signInHeadless: !signUp && options?.signInHeadless ? true : undefined,
-        ...(extraCapabilities ?? {}),
-    };
-    /* SAFETY: the connect method's response shape, which the dialog route answers. */
-    const result = (await dialog.request(METHODS.connect, [
-        { capabilities },
-    ]));
-    const { jwt, refreshToken, user, credential, webauthn, additionalSessions } = result;
-    // An email-only login carries no credential — mirror the guest handling:
-    // nothing is persisted to IDB (reserved for a real passkey credential) and
-    // the address stays null until a passkey is added.
-    const address = credential ? credentialToAddress(credential) : null;
-    if (credential)
-        await idb.set(CREDENTIAL_KEY, credential);
-    store.setState({ user, jwt, credential, address });
-    return {
-        session: { user, jwt, credential, address },
-        refreshToken,
-        webauthn,
-        additionalSessions: additionalSessions ? additionalSessions : undefined,
-    };
-}
 /**
  * Clears local-only auth state: active credential in IDB, the access key for
  * the current address (if any), and the in-memory store. Does NOT touch the

package/dist/sdk/client/static-flow.js

@@ -44,6 +44,7 @@ export function createStaticFlow(state, options = {}) {
             return snapshot.user?.isGuest === true;
         },
         login: () => unavailable("login"),
+        openAccount: () => unavailable("openAccount"),
         logout: () => unavailable("logout"),
         restore: async () => false,
         ensureGuest: () => unavailable("ensureGuest"),

package/dist/sdk/react/hooks.d.ts

@@ -28,7 +28,7 @@ export declare function useFlowId(): {
     address: `0x${string}` | null;
     isAuthenticated: boolean;
     isGuest: boolean;
-    login: (options?: import("../types").LoginOptions) => Promise<import("../types").Session>;
+    login: (options?: import("../types").LoginOptions) => Promise<never>;
     logout: () => Promise<void>;
     restore: () => Promise<boolean>;
     ensureGuest: () => Promise<boolean>;

package/dist/sdk/react/profile-button.d.ts

@@ -1,14 +1,3 @@
 import type { ProfileButtonProps } from "../types";
-/**
- * Drops the universal Flow ID profile button into a React tree. Renders a host
- * element (style it via `className` for placement/padding — e.g. top-right) that
- * the pill iframe mounts into; the iframe itself is sized to its content and
- * expands to the profile dialog on click. Resolves the Flow instance from a
- * `<FlowIdProvider>` or the createFlow() singleton.
- *
- * A changing `theme` recolors the mounted pill over its open bridge rather than
- * remounting it: `theme` is deliberately absent from the mount effect's deps,
- * because tearing the iframe down on a light/dark toggle reloads the widget and
- * drops the pill out of the host's layout mid-toggle.
- */
+/** Mount the native account button with access to the current Flow session. */
 export declare function ProfileButton({ className, host, theme }: ProfileButtonProps): import("react/jsx-runtime").JSX.Element;

package/dist/sdk/react/profile-button.js

@@ -2,18 +2,7 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import { useEffect, useRef } from "react";
 import { createProfileButton } from "../client/profile-button";
 import { useFlow } from "./hooks";
-/**
- * Drops the universal Flow ID profile button into a React tree. Renders a host
- * element (style it via `className` for placement/padding — e.g. top-right) that
- * the pill iframe mounts into; the iframe itself is sized to its content and
- * expands to the profile dialog on click. Resolves the Flow instance from a
- * `<FlowIdProvider>` or the createFlow() singleton.
- *
- * A changing `theme` recolors the mounted pill over its open bridge rather than
- * remounting it: `theme` is deliberately absent from the mount effect's deps,
- * because tearing the iframe down on a light/dark toggle reloads the widget and
- * drops the pill out of the host's layout mid-toggle.
- */
+/** Mount the native account button with access to the current Flow session. */
 export function ProfileButton({ className, host, theme }) {
     const flow = useFlow();
     const ref = useRef(null);

package/dist/sdk/session-route.js

@@ -1,4 +1,7 @@
 import { z } from "zod";
+import { browserCompletionSchema } from "./browser-contract";
+import { finishBrowserSession, startBrowserSession, } from "./browser-session-route";
+import { clearCookieString } from "./cookies";
 /**
  * The first-party session route every consumer app serves from its own
  * origin — the only path between a browser and the refresh token. The
@@ -21,13 +24,20 @@ import { z } from "zod";
  */
 import { cookieNamesFor, parseCookieHeader } from "./cookies";
 import { DEFAULT_SESSION_PATH, defaultAudience, resolveIdHost, } from "./id-host";
-import { claimsToUser, clearingCookies, isJwtVerificationFailure, resolveSessionCore, sessionCookies, } from "./session-core";
+import { claimsToUser, clearingCookies, isJwtVerificationFailure, refreshSessionCore, resolveSessionCore, sessionCookies, } from "./session-core";
 import { verifyFlowJWT } from "./verify";
 /** The body the browser SDK posts to its own app's session route. */
 const installBodySchema = z.object({
     refreshToken: z.string().min(1).optional(),
     jwt: z.string().min(1).optional(),
     mint: z.array(z.string()).optional(),
+    action: z.enum(["login", "account", "guest"]).optional(),
+    returnTo: z.string().optional(),
+    signUp: z.boolean().optional(),
+    accessKeyHash: z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{64}$/)
+        .optional(),
 });
 const additionalBodySchema = z.object({
     additionalSessions: z
@@ -72,17 +82,100 @@ function isCrossSite(request, audience) {
 export async function handleSessionRequest(request, opts = {}) {
     const audience = opts.audience ?? defaultAudience(new URL(request.url).origin);
     const issuerUrl = resolveIdHost(opts.issuerUrl, audience);
+    const callback = new URL(request.url);
+    if (request.method === "GET" && callback.searchParams.has("flow_state")) {
+        return finishBrowserSession(request, audience, issuerUrl);
+    }
     if (isCrossSite(request, audience)) {
         return json({ state: null }, 403);
     }
     switch (request.method) {
         case "GET": {
+            if (new URL(request.url).searchParams.get("refresh") === "1") {
+                const token = parseCookieHeader(request.headers.get("Cookie"))[cookieNamesFor(audience).refresh];
+                if (!token)
+                    return json({ state: null }, 200);
+                const result = await refreshSessionCore(issuerUrl, audience, token);
+                if (result === "dead")
+                    return json({ state: null }, 200, clearingCookies(audience));
+                if (!result)
+                    return json({ state: null }, 502);
+                return json({ state: result.session }, 200, result.setCookies);
+            }
             const { session, setCookies } = await resolveSessionCore(request.headers.get("Cookie"), audience, issuerUrl);
-            return json({ state: session }, 200, setCookies);
+            const completionName = `${cookieNamesFor(audience).refresh}.completion`;
+            const raw = parseCookieHeader(request.headers.get("Cookie"))[completionName];
+            let loginCompletion;
+            if (raw) {
+                setCookies.push(clearCookieString(completionName, {
+                    secure: audience.startsWith("https:"),
+                }));
+                try {
+                    const parsed = browserCompletionSchema.safeParse(JSON.parse(decodeURIComponent(atob(raw))));
+                    if (parsed.success &&
+                        parsed.data.expires > Date.now() &&
+                        parsed.data.userId === session?.user.id)
+                        loginCompletion = parsed.data;
+                }
+                catch { }
+            }
+            return json({ state: session, loginCompletion }, 200, setCookies);
         }
         case "POST": {
             const parsed = installBodySchema.safeParse(await request.json().catch(() => null));
             const body = parsed.success ? parsed.data : null;
+            if (body?.action === "login" || body?.action === "account") {
+                try {
+                    return await startBrowserSession(request, audience, issuerUrl, {
+                        ...body,
+                        action: body.action,
+                    });
+                }
+                catch {
+                    return json({ state: null }, 502);
+                }
+            }
+            if (body?.action === "guest") {
+                const existing = await resolveSessionCore(request.headers.get("Cookie"), audience, issuerUrl);
+                if (existing.session)
+                    return json({ state: existing.session }, 200, existing.setCookies);
+                const previousRefresh = parseCookieHeader(request.headers.get("Cookie"))[cookieNamesFor(audience).refresh];
+                if (previousRefresh && existing.setCookies.length === 0)
+                    return json({ state: null }, 502);
+                try {
+                    const headers = new Headers({ "Content-Type": "application/json" });
+                    for (const name of [
+                        "cf-connecting-ip",
+                        "x-forwarded-for",
+                        "user-agent",
+                    ]) {
+                        const value = request.headers.get(name);
+                        if (value)
+                            headers.set(name, value);
+                    }
+                    const result = await fetch(`${issuerUrl}/api/auth/passkey/guest`, {
+                        method: "POST",
+                        headers,
+                        body: JSON.stringify({ audience }),
+                    });
+                    if (!result.ok)
+                        return json({ state: null }, result.status);
+                    // SAFETY: the configured issuer returns this session token pair, verified below.
+                    const data = (await result.json());
+                    const claims = await verifyFlowJWT(data.jwt, { audience, issuerUrl });
+                    return json({
+                        state: {
+                            user: claimsToUser(claims),
+                            jwt: data.jwt,
+                            credential: null,
+                            address: null,
+                        },
+                    }, 200, sessionCookies(audience, data.jwt, data.refreshToken));
+                }
+                catch {
+                    return json({ state: null }, 502);
+                }
+            }
             // Reconcile mint: the browser asks its own server to obtain additional-
             // audience sessions (e.g. talk.flow.game) authorized by the PRIMARY
             // refresh cookie, for an embed that booted with no session of its own.
@@ -137,12 +230,16 @@ export async function handleSessionRequest(request, opts = {}) {
             // an unreachable issuer just leaves the lineage to expire on its own.
             if (token) {
                 try {
-                    await fetch(`${issuerUrl}/api/session/revoke`, {
+                    const response = await fetch(`${issuerUrl}/api/session/revoke`, {
                         method: "POST",
                         headers: { Authorization: `Bearer ${token}` },
                     });
+                    if (!response.ok)
+                        return json({ state: null }, 502);
+                }
+                catch {
+                    return json({ state: null }, 502);
                 }
-                catch { }
             }
             const headers = new Headers({ "Cache-Control": "no-store" });
             for (const cookie of clearingCookies(audience)) {

package/dist/sdk/types/dialog.d.ts

@@ -1,4 +1,3 @@
-import type { RpcRequest } from "./protocol";
 /**
  * Async view state for a dialog panel — the three states every fetched
  * section renders (spinner / retry row / content), so "empty" stays
@@ -91,7 +90,6 @@ export type DialogState = {
     customLabels?: DialogCustomLabels;
 };
 export type SignUpProps = {
-    request: RpcRequest;
     rpId: string;
     accessKeyHash?: string | undefined;
     guestToken?: string | undefined;
@@ -99,7 +97,6 @@ export type SignUpProps = {
     onSignIn: () => void;
 };
 export type SignInWithEmailProps = {
-    request: RpcRequest;
     onBack: () => void;
     onHome: () => void;
 };

package/dist/sdk/types/index.d.ts

@@ -16,7 +16,7 @@ export { getConnectCapabilities, isPersonalSignParams, isSendCallsParams, isSend
 export type { ReportOperation, ReportRequest, ReportResponse, ReportsApi, ReportTransport, } from "./reports";
 export type { CreateRoomEventInput, RoomEventArchive, RoomEventAttendance, RoomEventFrequency, RoomEventInstance, RoomEventInterest, RoomEventInterestState, RoomEventList, RoomEventOccurrence, RoomEventRecurrence, RoomEventRoomRef, RoomEventRun, RoomEventSeries, RoomEventStatus, SetInterestInput, UpdateRoomEventInput, } from "./room-events";
 export type { CreateRoomInput, GlobalRole, ModerationSubject, MyRooms, PlayerPositionReport, RoleChangeVerdict, RoomCapabilities, RoomCapability, RoomChannel, RoomDetail, RoomList, RoomMemberEntry, RoomMembers, RoomOccupancy, RoomOwner, RoomPlayerPosition, RoomPresenceEntry, RoomPresenceSnapshot, RoomRestrictionKind, RoomRole, RoomSummary, RoomSurfaceSettings, RoomsApi, RoomVisibility, StaffEntry, UpdateRoomInput, VerifyRoomContext, Viewer, VoiceDecisionReason, VoiceDecisionSubject, VoiceRoomDecision, } from "./rooms";
-export type { AccessKeyOptions, AccessKeyPreparation, Address, ColorScheme, CreateDialogHostOptions, CreateFlowOptions, DialogHost, DialogOpenOptions, FinalizeAccessKeyParams, Flow, FlowConnectorParameters, FlowCookieNames, FlowIdProviderProps, FlowSessionState, FlowState, FlowWidgetHandle, FlowWidgetName, FlowWidgetProps, Listener, LoginOptions, MountFlowWidgetOptions, MountProfileOptions, OpenProfileOptions, PrepareArgsWithAuth, PrepareTransactionRequestPhase, ProfileButtonHandle, ProfileButtonProps, ProfilePosition, ResolveAccountParams, ResolvedAccessKeyOptions, RootCredential, RunLoginParams, RunLoginResult, SendCallsArgs, SendTransactionArgs, Session, SigningContext, SignMessageArgs, SignTypedDataArgs, Store, StoredAccessKey, UseOpenProfileOptions, WagmiConnectCapabilities, WagmiConnectParams, } from "./sdk";
+export type { AccessKeyOptions, AccessKeyPreparation, Address, ColorScheme, CreateDialogHostOptions, CreateFlowOptions, DialogHost, DialogOpenOptions, FinalizeAccessKeyParams, Flow, FlowConnectorParameters, FlowCookieNames, FlowIdProviderProps, FlowSessionState, FlowState, FlowWidgetHandle, FlowWidgetName, FlowWidgetProps, Listener, LoginOptions, MountFlowWidgetOptions, MountProfileOptions, OpenProfileOptions, PrepareArgsWithAuth, PrepareTransactionRequestPhase, ProfileButtonHandle, ProfileButtonProps, ProfilePosition, ResolveAccountParams, ResolvedAccessKeyOptions, RootCredential, SendCallsArgs, SendTransactionArgs, Session, SigningContext, SignMessageArgs, SignTypedDataArgs, Store, StoredAccessKey, UseOpenProfileOptions, WagmiConnectCapabilities, WagmiConnectParams, } from "./sdk";
 export type { GracefulShutdownCleanup, GracefulShutdownOptions, GracefulShutdownServer, GracefulShutdownSignal, ResolvedFlowSession, ResolveSessionOptions, SessionRouteOptions, SessionRouteResponse, SessionRouteSession, } from "./server";
 export type { CosmeticOffer, PaintDescriptor, SettingDescriptor, Settings, SettingsMigration, StoredSettings, SurfaceRegistry, } from "./settings";
 export type { CreateStudySubjectInput, ListStudySessionsInput, StudyCatalog, StudyCategory, StudyCategoryTotals, StudyField, StudyRange, StudySessionEntry, StudySessionPage, StudySessionsResult, StudySubject, StudySubjectCreation, StudySubjectList, StudySubjectRefusal, StudySubjectRemoval, StudySubjectRemovalResponse, StudySubjectTotals, StudySubjectUpdate, StudySummary, UpdateStudySubjectInput, } from "./study";

package/dist/sdk/types/landing.d.ts

@@ -1,5 +1,6 @@
 import type { FlowUser } from "./auth";
 export type AccountProfileData = FlowUser & {
+    bio?: string | null;
     email?: string | null;
     emailVerified?: boolean;
     subscribedToNews?: boolean;