@flow-industries/id 0.24.5 → 0.25.0

package/dist/sdk/browser-session-route.d.ts

@@ -1,6 +1,7 @@
 export declare function safeReturnTo(value: string, audience: string, sessionPath?: string): string | null;
 export declare function startBrowserSession(request: Request, audience: string, issuerUrl: string, body: {
-    action: "login" | "account";
+    action: "login" | "account" | "switch";
+    intent?: "login" | "manage" | "switch" | "add";
     redirect?: boolean;
     returnTo?: string;
     signUp?: boolean;

package/dist/sdk/browser-session-route.js

@@ -2,7 +2,7 @@ import { z } from "zod";
 import { BROWSER_FLOW_TTL_MS, browserSigningSchema } from "./browser-contract";
 import { clearCookieString, cookieNamesFor, parseCookieHeader, serializeCookie, } from "./cookies";
 import { fetchIssuerApi, resolveIssuerApiUrl } from "./issuer-api";
-import { claimsToUser, sessionCookies } from "./session-core";
+import { claimsToUser, resolveSessionCore, sessionCookies, } from "./session-core";
 import { verifyFlowJWT } from "./verify";
 const opaquePattern = /^[A-Za-z0-9_-]{43}$/;
 const pendingSchema = z.object({
@@ -10,6 +10,7 @@ const pendingSchema = z.object({
     verifier: z.string().regex(opaquePattern),
     returnTo: z.string(),
     expires: z.number(),
+    manageAccount: z.boolean().optional(),
 });
 const exchangeSchema = z.object({
     jwt: z.string(),
@@ -62,8 +63,13 @@ export function safeReturnTo(value, audience, sessionPath = "/flow/session") {
     }
 }
 export async function startBrowserSession(request, audience, issuerUrl, body, apiUrl = resolveIssuerApiUrl(issuerUrl)) {
+    const sessionPath = new URL(request.url).pathname;
+    const returnTo = safeReturnTo(body.returnTo ?? "/", audience, sessionPath);
+    if (!returnTo)
+        return reply({ error: "invalid_return_destination" }, 400);
     const cookies = parseCookieHeader(request.headers.get("Cookie"));
-    const refresh = cookies[cookieNamesFor(audience).refresh];
+    const refreshCookieName = cookieNamesFor(audience).refresh;
+    const refresh = cookies[refreshCookieName];
     const headers = new Headers({ "Content-Type": "application/json" });
     if (refresh)
         headers.set("Authorization", `Bearer ${refresh}`);
@@ -72,65 +78,80 @@ export async function startBrowserSession(request, audience, issuerUrl, body, ap
         if (value)
             headers.set(name, value);
     }
+    let manageAccount = false;
+    let sessionUpdates = [];
     if (body.action === "account") {
         if (!refresh)
             return reply({ error: "signed_out" }, 401);
-        const response = await fetchIssuerApi(`${apiUrl}/api/auth/browser/account-handoff`, { method: "POST", headers, body: JSON.stringify({ audience }) });
+        const resolved = await resolveSessionCore(request.headers.get("Cookie"), audience, issuerUrl, apiUrl);
+        sessionUpdates = resolved.setCookies;
+        if (!resolved.session)
+            return reply({ error: "account_unavailable" }, 401, sessionUpdates);
+        manageAccount = !resolved.session.user.isGuest;
+        const refreshedCookie = sessionUpdates.find((cookie) => cookie.startsWith(`${refreshCookieName}=`));
+        if (refreshedCookie) {
+            const token = parseCookieHeader(refreshedCookie)[refreshCookieName];
+            if (token)
+                headers.set("Authorization", `Bearer ${token}`);
+        }
+    }
+    try {
+        let intent = body.intent ?? "login";
+        if (body.action === "account")
+            intent = manageAccount ? "manage" : "login";
+        if (body.action === "switch")
+            intent = "switch";
+        const state = secret();
+        const verifier = secret();
+        const callback = `${audience}${sessionPath}`;
+        const response = await fetchIssuerApi(`${apiUrl}/api/auth/browser/transaction`, {
+            method: "POST",
+            headers,
+            body: JSON.stringify({
+                audience,
+                callback,
+                state,
+                challenge: await pkce(verifier),
+                signUp: body.signUp ?? false,
+                intent,
+                accessKeyHash: body.accessKeyHash,
+            }),
+        });
         if (!response.ok)
-            return reply({ error: "account_unavailable" }, response.status);
-        const { handoff } = z
-            .object({ handoff: z.string().regex(opaquePattern) })
+            return reply({ error: "login_unavailable" }, response.status, sessionUpdates);
+        const { transaction } = z
+            .object({ transaction: z.string().regex(opaquePattern) })
             .parse(await response.json());
-        const accountUrl = `${issuerUrl}/account#handoff=${handoff}`;
-        if (body.redirect)
-            return new Response(null, {
-                status: 303,
-                headers: {
-                    Location: accountUrl,
-                    "Cache-Control": "no-store",
-                    "Referrer-Policy": "no-referrer",
-                },
+        const pending = btoa(encodeURIComponent(JSON.stringify({
+            state,
+            verifier,
+            returnTo,
+            manageAccount,
+            expires: Date.now() + BROWSER_FLOW_TTL_MS,
+        })));
+        const authorizeUrl = `${issuerUrl}/authorize?transaction=${transaction}`;
+        const pendingCookies = [
+            ...sessionUpdates,
+            serializeCookie(cookieName(audience, state), pending, {
+                maxAge: BROWSER_FLOW_TTL_MS / 1000,
+                secure: audience.startsWith("https:"),
+            }),
+        ];
+        if (body.redirect) {
+            const headers = new Headers({
+                Location: authorizeUrl,
+                "Cache-Control": "no-store",
+                "Referrer-Policy": "no-referrer",
             });
-        return reply({ accountUrl });
+            for (const cookie of pendingCookies)
+                headers.append("Set-Cookie", cookie);
+            return new Response(null, { status: 303, headers });
+        }
+        return reply({ loginId: state, authorizeUrl, accountUrl: authorizeUrl }, 200, pendingCookies);
+    }
+    catch {
+        return reply({ error: "login_unavailable" }, 502, sessionUpdates);
     }
-    const returnTo = safeReturnTo(body.returnTo ?? "/", audience, new URL(request.url).pathname);
-    if (!returnTo)
-        return reply({ error: "invalid_return_destination" }, 400);
-    const state = secret();
-    const verifier = secret();
-    const callback = `${audience}${new URL(request.url).pathname}`;
-    const response = await fetchIssuerApi(`${apiUrl}/api/auth/browser/transaction`, {
-        method: "POST",
-        headers,
-        body: JSON.stringify({
-            audience,
-            callback,
-            state,
-            challenge: await pkce(verifier),
-            signUp: body.signUp ?? false,
-            accessKeyHash: body.accessKeyHash,
-        }),
-    });
-    if (!response.ok)
-        return reply({ error: "login_unavailable" }, response.status);
-    const { transaction } = z
-        .object({ transaction: z.string().regex(opaquePattern) })
-        .parse(await response.json());
-    const pending = btoa(encodeURIComponent(JSON.stringify({
-        state,
-        verifier,
-        returnTo,
-        expires: Date.now() + BROWSER_FLOW_TTL_MS,
-    })));
-    return reply({
-        loginId: state,
-        authorizeUrl: `${issuerUrl}/authorize?transaction=${transaction}`,
-    }, 200, [
-        serializeCookie(cookieName(audience, state), pending, {
-            maxAge: BROWSER_FLOW_TTL_MS / 1000,
-            secure: audience.startsWith("https:"),
-        }),
-    ]);
 }
 export async function finishBrowserSession(request, audience, issuerUrl, apiUrl = resolveIssuerApiUrl(issuerUrl)) {
     const url = new URL(request.url);
@@ -200,6 +221,8 @@ export async function finishBrowserSession(request, audience, issuerUrl, apiUrl
             headers.append("Set-Cookie", serializeCookie(`${cookieNamesFor(audience).refresh}.completion`, completion, { maxAge: 60, secure: audience.startsWith("https:") }));
         }
         headers.append("Set-Cookie", clear);
+        if (pending.manageAccount)
+            headers.set("Location", `${issuerUrl}/account`);
         return new Response(null, { status: 303, headers });
     }
     catch {

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

@@ -112,11 +112,20 @@ export function createFlow(options = {}) {
      * knows neither, and overwriting would erase state restored from IDB.
      */
     let additionalSubject = null;
-    function commitSession(session) {
-        const previous = store.getSnapshot().user?.id;
+    let sessionRevision = 0;
+    async function commitSession(session) {
+        const revision = ++sessionRevision;
+        const previousState = store.getSnapshot();
+        const previous = previousState.user?.id;
         if (previous && previous !== session.user.id) {
             store.setState({ credential: null, address: null });
-            void idb.delete("flow.activeCredential");
+            await idb.delete("flow.activeCredential");
+            if (previousState.address) {
+                const { clearAccessKey } = await import("./access-key");
+                await clearAccessKey(previousState.address);
+            }
+            if (revision !== sessionRevision)
+                return;
         }
         const next = {
             user: session.user,
@@ -147,6 +156,7 @@ export function createFlow(options = {}) {
         }
     }
     async function recoverAccessKey(state, loginCompletion) {
+        const revision = sessionRevision;
         const completionKey = "flow.pendingAccessKey.completion";
         if (loginCompletion)
             await idb.set(completionKey, {
@@ -164,10 +174,11 @@ export function createFlow(options = {}) {
                     throw new Error("Could not restore signing state");
                 // SAFETY: the app session handler returns the SDK protocol response.
                 const resolved = (await fresh.json());
-                if (resolved.state?.user.id === completion.userId &&
+                if (revision === sessionRevision &&
+                    resolved.state?.user.id === completion.userId &&
                     resolved.state.credential &&
                     resolved.state.address) {
-                    commitSession(resolved.state);
+                    await commitSession(resolved.state);
                     const { finalizeAccessKey } = await import("./access-key");
                     await finalizeAccessKey({
                         address: resolved.state.address,
@@ -189,7 +200,13 @@ export function createFlow(options = {}) {
      * false (never throws) when the visitor is signed out or the route is
      * unreachable — the caller then falls back to ensureGuest()/login().
      */
+    let sessionRequest = 0;
+    let logoutInFlight = null;
+    let logoutGeneration = 0;
     async function refreshViaSession() {
+        if (logoutInFlight)
+            return false;
+        const request = ++sessionRequest;
         try {
             const res = await fetch(sessionPath, {
                 headers: { Accept: "application/json" },
@@ -198,9 +215,9 @@ export function createFlow(options = {}) {
                 return false;
             // SAFETY: the app's own /flow/session route answers this shape.
             const { state, loginCompletion } = (await res.json());
-            if (!state)
+            if (!state || request !== sessionRequest)
                 return false;
-            commitSession(state);
+            await commitSession(state);
             await recoverAccessKey(state, loginCompletion).catch(() => { });
             return true;
         }
@@ -240,7 +257,11 @@ export function createFlow(options = {}) {
     // and the guard short-circuits a caller that arrives after a concurrent
     // holder already minted a fresh JWT.
     async function doRefresh() {
+        if (logoutInFlight)
+            return false;
         return withOriginLock("flow.id.refresh", async () => {
+            if (logoutInFlight)
+                return false;
             const current = store.getSnapshot().jwt;
             if (current && !isExpiring(current))
                 return true;
@@ -290,18 +311,27 @@ export function createFlow(options = {}) {
      * in-memory store (never IDB) — IDB is reserved for a real passkey credential.
      */
     async function ensureGuest() {
+        if (logoutInFlight)
+            return false;
         if (store.getSnapshot().user)
             return true;
         if (!guestInFlight) {
+            const generation = logoutGeneration;
             guestInFlight = withOriginLock("flow.id.guest", async () => {
                 // Re-check under the lock: another tab may have minted the guest while
                 // we waited. Refresh-first (from this origin's session cookie)
                 // recovers an existing session instead of minting a duplicate guest.
+                if (logoutInFlight || generation !== logoutGeneration)
+                    return false;
                 if (store.getSnapshot().user)
                     return true;
-                if (await doRefresh())
+                const restored = await doRefresh();
+                if (logoutInFlight || generation !== logoutGeneration)
+                    return false;
+                if (restored)
                     return true;
                 try {
+                    const request = ++sessionRequest;
                     const response = await fetch(sessionPath, {
                         method: "POST",
                         headers: { "Content-Type": "application/json" },
@@ -311,9 +341,9 @@ export function createFlow(options = {}) {
                         return false;
                     // SAFETY: the app session handler returns the SDK protocol response.
                     const result = (await response.json());
-                    if (!result.state)
+                    if (!result.state || request !== sessionRequest)
                         return false;
-                    commitSession(result.state);
+                    await commitSession(result.state);
                     return true;
                 }
                 catch {
@@ -329,13 +359,16 @@ export function createFlow(options = {}) {
         void idb.pruneExpired("flow.pendingAccessKey.").catch(() => { });
         if (options.autoRestore !== false) {
             const restored = await refreshViaSession();
-            if (restored) {
+            if (restored && !logoutInFlight) {
+                const request = ++sessionRequest;
                 const response = await fetch(`${sessionPath}?refresh=1`);
                 if (response.ok) {
                     // SAFETY: the app session handler returns the SDK protocol response.
                     const result = (await response.json());
+                    if (request !== sessionRequest)
+                        return;
                     if (result.state)
-                        commitSession(result.state);
+                        await commitSession(result.state);
                     else
                         await runLogout(store);
                 }
@@ -357,11 +390,17 @@ export function createFlow(options = {}) {
     }
     /** Starts top-level authentication; successful navigation never resolves in this document. */
     async function login(loginOpts = {}) {
+        return startLogin(loginOpts, "login");
+    }
+    async function switchAccounts(loginOpts = {}) {
+        return startLogin(loginOpts, "switch");
+    }
+    async function startLogin(loginOpts, intent) {
         if (window.top !== window) {
             throw new Error("Open sign-in from the containing app.");
         }
         let preparation;
-        if (accessKeyOptions) {
+        if (accessKeyOptions && intent === "login") {
             const chain = getChain();
             if (!chain)
                 throw new Error("accessKey requires a configured chain");
@@ -372,7 +411,7 @@ export function createFlow(options = {}) {
             method: "POST",
             headers: { "Content-Type": "application/json" },
             body: JSON.stringify({
-                action: "login",
+                action: intent,
                 accessKeyHash: preparation?.accessKeyHash,
                 signUp: loginOpts.signUp,
                 returnTo: loginOpts.returnTo ??
@@ -396,6 +435,7 @@ export function createFlow(options = {}) {
     function openAccount() {
         const url = new URL(sessionPath, window.location.origin);
         url.searchParams.set("action", "account");
+        url.searchParams.set("returnTo", `${window.location.pathname}${window.location.search}${window.location.hash}`);
         const tab = window.open(url.href, "_blank");
         if (!tab)
             return false;
@@ -403,19 +443,37 @@ export function createFlow(options = {}) {
         return true;
     }
     async function logout() {
-        const response = await fetch(sessionPath, { method: "DELETE" });
-        if (!response.ok)
-            throw new Error("Could not sign out. Try again.");
-        await runLogout(store);
-        additionalSubject = null;
+        if (logoutInFlight)
+            return logoutInFlight;
+        ++logoutGeneration;
+        ++sessionRequest;
+        ++sessionRevision;
+        logoutInFlight = (async () => {
+            const response = await fetch(sessionPath, { method: "DELETE" });
+            if (!response.ok)
+                throw new Error("Could not sign out. Try again.");
+            ++sessionRequest;
+            ++sessionRevision;
+            await runLogout(store);
+            additionalSubject = null;
+        })();
+        try {
+            await logoutInFlight;
+        }
+        finally {
+            logoutInFlight = null;
+        }
         if (options.autoGuest)
             await ensureGuest();
     }
     let focusRefresh = null;
     const refreshOnFocus = () => {
-        if (document.visibilityState === "hidden" || focusRefresh)
+        if (document.visibilityState === "hidden" || focusRefresh || logoutInFlight)
             return;
         focusRefresh = withOriginLock("flow.id.refresh", async () => {
+            if (logoutInFlight)
+                return;
+            const request = ++sessionRequest;
             const response = await fetch(`${sessionPath}?refresh=1`, {
                 headers: { Accept: "application/json" },
             });
@@ -423,8 +481,10 @@ export function createFlow(options = {}) {
                 return;
             // SAFETY: the app session handler returns the SDK protocol response.
             const result = (await response.json());
+            if (request !== sessionRequest)
+                return;
             if (result.state)
-                commitSession(result.state);
+                await commitSession(result.state);
             else
                 await runLogout(store);
         })
@@ -456,6 +516,7 @@ export function createFlow(options = {}) {
         },
         login,
         openAccount,
+        switchAccounts,
         logout,
         restore: refreshViaSession,
         ensureGuest,

package/dist/sdk/client/session.js

@@ -28,12 +28,12 @@ export async function restoreCredential(store) {
  */
 export async function runLogout(store) {
     const state = store.getSnapshot();
+    store.setState(initialFlowState);
     if (state.address) {
         const { clearAccessKey } = await import("./access-key");
         await clearAccessKey(state.address);
     }
     await idb.delete(CREDENTIAL_KEY);
-    store.setState(initialFlowState);
 }
 /**
  * Derives the user's wallet address from their passkey public key by

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

@@ -45,6 +45,7 @@ export function createStaticFlow(state, options = {}) {
         },
         login: () => unavailable("login"),
         openAccount: () => unavailable("openAccount"),
+        switchAccounts: () => unavailable("switchAccounts"),
         logout: () => unavailable("logout"),
         restore: async () => false,
         ensureGuest: () => unavailable("ensureGuest"),

package/dist/sdk/db/schema.d.ts

@@ -651,6 +651,173 @@ export declare const session: import("drizzle-orm/pg-core").PgTableWithColumns<{
     };
     dialect: "pg";
 }>;
+export declare const browserAccountSet: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "browser_account_set";
+    schema: undefined;
+    columns: {
+        initialized: import("drizzle-orm/pg-core").PgColumn<{
+            name: "initialized";
+            tableName: "browser_account_set";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "browser_account_set";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        activeUserId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "active_user_id";
+            tableName: "browser_account_set";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "browser_account_set";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export declare const browserAccountMember: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "browser_account_member";
+    schema: undefined;
+    columns: {
+        setId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "set_id";
+            tableName: "browser_account_member";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        userId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "user_id";
+            tableName: "browser_account_member";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        sessionId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "session_id";
+            tableName: "browser_account_member";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        userEpoch: import("drizzle-orm/pg-core").PgColumn<{
+            name: "user_epoch";
+            tableName: "browser_account_member";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        lastUsedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "last_used_at";
+            tableName: "browser_account_member";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
 export declare const refreshToken: import("drizzle-orm/pg-core").PgTableWithColumns<{
     name: "refresh_token";
     schema: undefined;

package/dist/sdk/db/schema.js

@@ -79,6 +79,25 @@ export const session = pgTable("session", {
     createdAt: timestamp("created_at").notNull().defaultNow(),
     updatedAt: timestamp("updated_at").notNull().defaultNow(),
 }, (table) => [index("session_userId_idx").on(table.userId)]);
+export const browserAccountSet = pgTable("browser_account_set", {
+    initialized: boolean("initialized").notNull().default(false),
+    id: text("id").primaryKey(),
+    activeUserId: text("active_user_id"),
+    updatedAt: timestamp("updated_at").notNull().defaultNow(),
+});
+export const browserAccountMember = pgTable("browser_account_member", {
+    setId: text("set_id")
+        .notNull()
+        .references(() => browserAccountSet.id, { onDelete: "cascade" }),
+    userId: text("user_id")
+        .notNull()
+        .references(() => user.id, { onDelete: "cascade" }),
+    sessionId: text("session_id")
+        .notNull()
+        .references(() => session.id, { onDelete: "cascade" }),
+    userEpoch: integer("user_epoch").notNull(),
+    lastUsedAt: timestamp("last_used_at").notNull().defaultNow(),
+}, (table) => [primaryKey({ columns: [table.setId, table.userId] })]);
 // First-party session persistence: consumer apps store the opaque token in their
 // OWN origin and mint access JWTs via POST /api/session/refresh — no third-party
 // id.flow.industries cookie, so it survives iOS ITP. Rotated on every use.

package/dist/sdk/session-route.js

@@ -32,7 +32,8 @@ 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(),
+    action: z.enum(["login", "account", "switch", "guest"]).optional(),
+    intent: z.enum(["login", "manage", "switch", "add"]).optional(),
     returnTo: z.string().optional(),
     signUp: z.boolean().optional(),
     accessKeyHash: z
@@ -95,7 +96,11 @@ export async function handleSessionRequest(request, opts = {}) {
         case "GET": {
             if (callback.searchParams.get("action") === "account") {
                 try {
-                    return await startBrowserSession(request, audience, issuerUrl, { action: "account", redirect: true }, apiUrl);
+                    return await startBrowserSession(request, audience, issuerUrl, {
+                        action: "account",
+                        redirect: true,
+                        returnTo: callback.searchParams.get("returnTo") ?? "/",
+                    }, apiUrl);
                 }
                 catch {
                     return json({ state: null }, 502);
@@ -134,7 +139,9 @@ export async function handleSessionRequest(request, opts = {}) {
         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") {
+            if (body?.action === "login" ||
+                body?.action === "account" ||
+                body?.action === "switch") {
                 try {
                     return await startBrowserSession(request, audience, issuerUrl, {
                         ...body,

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

@@ -176,6 +176,7 @@ export type AccountRegistration = {
     credential: FlowCredential | null;
 };
 export type AuthorizationTransaction = {
+    intent: "login" | "manage" | "switch" | "add";
     expiresAt: number;
     accessKeyHash?: string;
     credentialId?: string;

package/dist/sdk/types/browser-accounts.d.ts

@@ -0,0 +1,9 @@
+export interface BrowserAccount {
+    id: string;
+    username: string;
+    image: string | null;
+}
+export interface BrowserAccounts {
+    accounts: BrowserAccount[];
+    activeUserId: string | null;
+}

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

@@ -2,6 +2,7 @@ export type { AccountDeleteRequest, AccountDeleteResponse, AccountErasureCounts,
 export type { ActionCurve, ActionEventRequest, ActionEventResponse, ActionsApi, ActiveActionState, FinishActionRequest, ListStudySessionsOptions, ListStudySubjectsOptions, StartActionInput, StartActionResult, StudyApi, StudySubjectResponse, UseActiveActionOptions, XpEstimateContext, } from "./actions";
 export type { AtprotoCompletion, AtprotoStartRequest, AtprotoStatus, } from "./atproto";
 export type { AccountRegistration, AccountSession, AccountSessionsResponse, AdditionalSession, AuthConfig, AuthorizationTransaction, AuthPageBootstrap, AuthResponse, AuthResponseWithWebAuthn, BioNormalization, BioRejection, BioWriteRefusal, BioWriteResult, FlowCredential, FlowUser, PasskeyEnrollment, PasskeyPluginOptions, RevokeAllSessionsResponse, RevokeSessionResponse, SecurityActivityEntry, SecurityActivityResponse, SessionUser, VerifiedFlowJWT, VerifyOptions, WebAuthnSignature, } from "./auth";
+export type { BrowserAccount, BrowserAccounts } from "./browser-accounts";
 export type { BodyRegion, CosmeticItem, CosmeticMaterial, CosmeticPaint, CosmeticSlot, EquipConflict, EquippedCosmetic, EquippedCosmetics, EquipRegion, PaintSlot, SettingsConflict, } from "./cosmetics";
 export { BODY_REGIONS, COSMETIC_MATERIALS } from "./cosmetics";
 export type { AccountDataDownload, AccountDataIdentity, BoundaryError, DialogCustomFeatures, DialogCustomLabels, DialogError, DialogReferrer, DialogState, Loadable, ProfileData, ProfileIdentity, SignInWithEmailProps, SignUpProps, } from "./dialog";

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

@@ -332,6 +332,7 @@ export type Flow = {
     readonly isGuest: boolean;
     login(options?: LoginOptions): Promise<never>;
     openAccount(): boolean;
+    switchAccounts(options?: Pick<LoginOptions, "returnTo">): Promise<never>;
     logout(): Promise<void>;
     restore(): Promise<boolean>;
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flow-industries/id",
-  "version": "0.24.5",
+  "version": "0.25.0",
   "license": "MIT",
   "repository": {
     "type": "git",