@oxy.so/services 1.1.0 → 2.0.0

package/src/ui/components/authChooser/SignUpView.tsx

@@ -1,37 +1,31 @@
 /**
  * Account creation (`signup` view).
  *
- * Commons is ALWAYS the priority path (owner mandate) and leads everywhere it
- * appears: native shows only "Create your identity in Commons" (or "Get Commons"
- * first, when it is not installed); web on a first-party Oxy origin leads with
- * the SAME "Get Commons" CTA, with inline passkey creation offered UNDERNEATH as
- * the de-emphasized "don't want to install anything" alternative — never
- * co-equal, never a competing button. Anywhere else (a non-Oxy web origin,
- * before the b2 hub-relay ships) shows an honest "not available here yet"
- * handoff instead of a broken button.
+ * Web: the account AND its self-custody identity are created at the identity
+ * origin (`id.oxy.so`), in the same window a passkey sign-in uses — never on
+ * this page, whatever its origin (one identity, two carriers). The sign-in
+ * entry's "create an account" link opens that window directly; this view is
+ * what `openAccountDialog('signup')` lands on, and offers the same one action.
+ *
+ * Native: Commons owns identity creation. Deep-link straight in when Commons is
+ * installed, else lead with the "Get Commons" acquisition CTA.
  */
 
 import type React from 'react';
-import { useState } from 'react';
-import { TextInput, View } from 'react-native';
+import { View } from 'react-native';
 import { Button } from '@oxy.so/bloom/button';
 import { Text } from '@oxy.so/bloom/typography';
-import type { AccountDialogSnapshot, OxyServices } from '@oxy.so/core';
-import { isWebBrowser } from '../../utils/isWebBrowser';
-import { Dividerish, SubtleLink } from './primitives';
+import type { AccountDialogSnapshot } from '@oxy.so/core';
+import { SubtleLink } from './primitives';
 import { authChooserStyles as styles } from './styles';
 import type { PasskeyMode, Theme, Translate } from './types';
-import { useUsernameAvailability, type UsernameStatus } from './useUsernameAvailability';
 
 interface SignUpViewProps {
   snapshot: AccountDialogSnapshot;
   theme: Theme;
   t: Translate;
-  oxyServices: OxyServices;
   passkeyMode: PasskeyMode;
-  onCreateWithPasskey: (username: string) => void;
-  createPending: boolean;
-  /** Open the auth.oxy.so hub popup (b2) — the 'hub' mode's only path. */
+  /** Open the identity-origin window — web's only creation path. */
   onOpenHub: () => void;
   /** Deep-link into Commons' own identity-creation screen (installed only). */
   onCreateIdentityInCommons: () => void;
@@ -44,22 +38,13 @@ const SignUpView: React.FC<SignUpViewProps> = ({
   snapshot,
   theme,
   t,
-  oxyServices,
   passkeyMode,
-  onCreateWithPasskey,
-  createPending,
   onOpenHub,
   onCreateIdentityInCommons,
   onGetCommons,
   onBackToSignIn,
 }) => {
-  const [username, setUsername] = useState('');
-  const { status: usernameStatus, check: checkUsername } = useUsernameAvailability(oxyServices, t);
-  const canSubmit = username.trim().length >= 3 && usernameStatus === 'available' && !createPending;
-
-  // Native — Commons owns identity creation. Deep-link straight in when it is
-  // installed, else lead with the same "Get Commons" acquisition CTA.
-  if (!isWebBrowser()) {
+  if (passkeyMode === 'none') {
     const commonsInstalled = snapshot.commonsAvailability === 'available';
     return (
       <View style={styles.centeredBlock}>
@@ -75,100 +60,17 @@ const SignUpView: React.FC<SignUpViewProps> = ({
     );
   }
 
-  // Web, first-party Oxy origin. Commons leads with a "Get Commons" CTA; passkey
-  // creation is the de-emphasized alternative underneath for someone who doesn't
-  // want to install anything — a secondary button introduced by its own "No
-  // Commons?" framing, the same subordination the sign-in surfaces use.
-  if (passkeyMode === 'direct') {
-    return (
-      <View style={styles.signInBlock}>
-        <Text style={[styles.qrHeadline, { color: theme.colors.text }]}>
-          {t('signup.commonsHeadline')}
-        </Text>
-        <Text style={[styles.mutedText, { color: theme.colors.textSecondary }]}>
-          {t('signup.commonsExplainer')}
-        </Text>
-        <Button variant="primary" onPress={onGetCommons} style={styles.primaryButton}>
-          {t('accountSwitcher.getCommons')}
-        </Button>
-
-        <Dividerish theme={theme} label={t('signin.or')} />
-
-        <Text style={[styles.mutedText, { color: theme.colors.textSecondary }]}>
-          {t('signup.passkeyAlternative')}
-        </Text>
-        <TextInput
-          style={[styles.usernameInput, { borderColor: theme.colors.border, color: theme.colors.text }]}
-          placeholder={t('signup.usernamePlaceholder')}
-          placeholderTextColor={theme.colors.textSecondary}
-          value={username}
-          autoCapitalize="none"
-          autoCorrect={false}
-          autoComplete="username"
-          onChangeText={(value) => {
-            setUsername(value);
-            checkUsername(value.trim());
-          }}
-          testID="signup-username-input"
-        />
-        <UsernameStatusText status={usernameStatus} theme={theme} t={t} />
-        <Button
-          variant="secondary"
-          onPress={() => onCreateWithPasskey(username.trim())}
-          disabled={!canSubmit}
-          style={styles.secondaryButton}
-          testID="signup-create-button"
-        >
-          {createPending ? t('signup.creating') : t('signup.createAccount')}
-        </Button>
-        <SubtleLink label={t('signup.backToSignInLink')} theme={theme} onPress={onBackToSignIn} />
-      </View>
-    );
-  }
-
-  // Web, non-Oxy origin (b2): a passkey ceremony cannot run locally here — the
-  // same WebAuthn RP-ID boundary the sign-in surfaces hit — so this opens the
-  // auth.oxy.so hub popup. Completing EITHER a sign-in OR a fresh sign-up there
-  // relays the resulting session back through the SAME poll/socket engine.
   return (
     <View style={styles.centeredBlock}>
       <Text style={[styles.mutedText, { color: theme.colors.textSecondary }]}>
-        {t('signup.hubExplainer')}
+        {t('accountSwitcher.passkeyHint')}
       </Text>
-      <Button variant="primary" onPress={onOpenHub} style={styles.primaryButton}>
-        {t('signup.continueInWindow')}
+      <Button variant="primary" onPress={onOpenHub} style={styles.primaryButton} testID="signup-open-identity">
+        {t('signup.createAccount')}
       </Button>
       <SubtleLink label={t('signup.backToSignInLink')} theme={theme} onPress={onBackToSignIn} />
     </View>
   );
 };
 
-/** The inline availability verdict. Network FAILURES are toasted, never shown here. */
-const UsernameStatusText: React.FC<{ status: UsernameStatus; theme: Theme; t: Translate }> = ({
-  status,
-  theme,
-  t,
-}) => {
-  if (status === 'idle') return null;
-  if (status === 'checking') {
-    return (
-      <Text style={[styles.mutedText, { color: theme.colors.textSecondary }]}>
-        {t('signup.usernameChecking')}
-      </Text>
-    );
-  }
-  if (status === 'available') {
-    return (
-      <Text style={[styles.mutedText, { color: theme.colors.success }]}>
-        {t('signup.usernameAvailable')}
-      </Text>
-    );
-  }
-  return (
-    <Text style={[styles.mutedText, { color: theme.colors.error }]}>
-      {t('signup.usernameTaken')}
-    </Text>
-  );
-};
-
 export default SignUpView;

package/src/ui/components/authChooser/signInFailureMessage.ts

@@ -0,0 +1,39 @@
+/**
+ * The localized toast for a failed sign-in attempt.
+ *
+ * One responsibility: turn the controller's machine-readable
+ * `signIn.failure` into copy. The controller ships no user-facing prose — its
+ * raw `signIn.error` is English or a server string, kept for diagnostics only.
+ */
+
+import type { SignInFailureReason } from '@oxy.so/core';
+import type { Translate } from './types';
+
+/**
+ * The toast for `failure`, or `null` when there is nothing to report: a
+ * `'cancelled'` attempt is the user's own choice (they closed the window), and
+ * the surface already offers "Try again" without scolding them for it.
+ */
+export function signInFailureMessage(
+  failure: SignInFailureReason | null,
+  t: Translate,
+): string | null {
+  switch (failure) {
+    case 'cancelled':
+      return null;
+    case 'denied':
+      return t('accountSwitcher.signInFailures.denied');
+    case 'expired':
+      return t('accountSwitcher.signInFailures.expired');
+    case 'network':
+      return t('accountSwitcher.signInFailures.network');
+    case 'not-configured':
+      return t('accountSwitcher.signInFailures.notConfigured');
+    case 'unsupported-flow':
+      return t('accountSwitcher.signInFailures.unsupportedFlow');
+    case 'claim-failed':
+      return t('accountSwitcher.signInFailures.claimFailed');
+    default:
+      return t('accountSwitcher.signInFailures.generic');
+  }
+}

package/src/ui/components/authChooser/types.ts

@@ -95,6 +95,11 @@ export interface AccountsMenuActions {
   onPrivacy: () => void;
   onTerms: () => void;
   onSignOut: () => void;
+  /**
+   * Open the person's identity at the identity origin (recovery phrase,
+   * recovery, account deletion). Web only — `undefined` hides the row.
+   */
+  onOpenIdentity?: () => void;
   customItems: readonly {
     key: string;
     label: string;
@@ -104,15 +109,13 @@ export interface AccountsMenuActions {
 }
 
 /**
- * Where a WebAuthn ceremony can run from the current origin.
+ * Where a passkey sign-in or sign-up can run from the current surface.
  *
- * A credential minted for `oxy.so` can only be ASSERTED there (or a loopback
- * dev host) — a hard, browser-enforced RP-ID boundary, not feature detection.
- * `'direct'` = a first-party Oxy web origin, the ceremony runs here.
- * `'hub'`    = any other web origin; it runs in the auth.oxy.so popup instead.
- * `'none'`   = native, where Commons owns identity.
+ * `'hub'`  = web: it runs at the identity origin (`id.oxy.so`) in a popup, on
+ *            every web origin, first-party or not.
+ * `'none'` = native, where Commons owns identity.
  */
-export type PasskeyMode = 'direct' | 'hub' | 'none';
+export type PasskeyMode = 'hub' | 'none';
 
 /**
  * Everything that is NOT the sign-in surface's one primary action.
@@ -125,17 +128,12 @@ export type PasskeyMode = 'direct' | 'hub' | 'none';
 export interface SignInAlternatives {
   /** Whether a WebAuthn ceremony is reachable from this origin at all. */
   passkeyAvailable: boolean;
-  /**
-   * `true` while a DIRECT ceremony is in flight. The hub-popup variant reports
-   * its progress through `snapshot.signIn` instead, so it never sets this.
-   */
-  passkeyPending: boolean;
   onSignInWithPasskey: () => void;
   /** Fall back to the cross-device QR handoff (restarts the request). */
   onShowQr: () => void;
   /** Open the Commons store listing / landing page for this platform. */
   onGetCommons: () => void;
-  /** Enter the account-creation view. */
+  /** Create an account: the identity-origin window on web, the Commons flow on native. */
   onCreateAccount: () => void;
 }
 

package/src/ui/context/OxyContext.tsx

@@ -95,7 +95,7 @@ import { DEFAULT_SESSION_VALIDITY_MS } from './oxyContextHelpers';
 // never dereferenced at module scope here.
 import { useFollow } from '../hooks/useFollow';
 import { commitDeviceSetAndResolve } from './commitSessionFlow';
-import { runPasskeyLogin, runPasskeyRegister, runPasskeyAdd } from './passkeyFlow';
+import { runPasskeyLogin, runPasskeyAdd } from './passkeyFlow';
 import {
   isPasskeySupported,
   runRegistrationCeremony,
@@ -104,7 +104,7 @@ import {
 import { queryKeys } from '../hooks/queries/queryKeys';
 import { useOxyAccountGraph } from './useOxyAccountGraph';
 
-export type { OxyContextState, OxyRuntimeProviderProps } from './oxyContextTypes';
+export type { LogoutResult, OxyContextState, OxyRuntimeProviderProps } from './oxyContextTypes';
 
 const OxyRuntimeContext = createContext<OxyContextState | null>(null);
 
@@ -959,22 +959,6 @@ export const OxyRuntimeProvider: React.FC<OxyRuntimeProviderProps> = ({
     [oxyServices, authStore, commitSession],
   );
 
-  // Create a brand-new account whose first auth method is a passkey.
-  const registerWithPasskey = useCallback(
-    async (params: { username: string; deviceName?: string }): Promise<void> => {
-      await runPasskeyRegister({
-        isSupported: isPasskeySupported,
-        getRegisterOptions: (username) => oxyServices.webauthnRegisterOptions(username),
-        runCeremony: runRegistrationCeremony,
-        registerVerify: (response, envelope) => oxyServices.webauthnRegisterVerify(response, envelope),
-        commit: (input) => commitSession(input, { activate: true }),
-        username: params.username,
-        deviceName: params.deviceName,
-      });
-    },
-    [oxyServices, commitSession],
-  );
-
   // Add a passkey to the already-signed-in account (bearer present). No new
   // session is committed — just refresh the linked auth-methods list.
   const addPasskey = useCallback(
@@ -1265,7 +1249,6 @@ export const OxyRuntimeProvider: React.FC<OxyRuntimeProviderProps> = ({
       getPublicKey,
       signIn,
       signInWithPasskey,
-      registerWithPasskey,
       addPasskey,
       removePasskey,
       revokeSuspiciousSignIn,
@@ -1323,7 +1306,6 @@ export const OxyRuntimeProvider: React.FC<OxyRuntimeProviderProps> = ({
       getPublicKey,
       signIn,
       signInWithPasskey,
-      registerWithPasskey,
       addPasskey,
       removePasskey,
       revokeSuspiciousSignIn,

package/src/ui/context/__tests__/passkeyFlow.test.ts

@@ -1,6 +1,6 @@
 /**
  * `passkeyFlow` — the pure, deps-injected passkey (WebAuthn) orchestration that
- * backs `useOxy().signInWithPasskey` / `registerWithPasskey` / `addPasskey`.
+ * backs `useOxy().signInWithPasskey` / `addPasskey`.
  *
  * These tests assert the fixed `options → ceremony → verify → commit` ordering,
  * the exact `commitSession` input projected from a session-arm login result, the
@@ -12,11 +12,9 @@
 import type { LoginSessionResult } from '@oxy.so/contracts';
 import {
   runPasskeyLogin,
-  runPasskeyRegister,
-  runPasskeyAdd,
+    runPasskeyAdd,
   PASSKEY_UNSUPPORTED_MESSAGE,
   type RunPasskeyLoginDeps,
-  type RunPasskeyRegisterDeps,
   type RunPasskeyAddDeps,
   type PasskeyRegisterVerifyResult,
 } from '../passkeyFlow';
@@ -122,67 +120,6 @@ describe('runPasskeyLogin', () => {
   });
 });
 
-describe('runPasskeyRegister', () => {
-  const buildDeps = (
-    order: string[],
-    overrides: Partial<RunPasskeyRegisterDeps> = {},
-  ): RunPasskeyRegisterDeps => ({
-    isSupported: jest.fn(() => true),
-    getRegisterOptions: jest.fn(async (username) => {
-      order.push('getRegisterOptions');
-      expect(username).toBe('newuser');
-      return { challenge: 'reg-opts' };
-    }),
-    runCeremony: jest.fn(async () => {
-      order.push('runCeremony');
-      return { id: 'attestation' };
-    }),
-    registerVerify: jest.fn(async () => {
-      order.push('registerVerify');
-      return sessionResult;
-    }),
-    commit: jest.fn(async () => {
-      order.push('commit');
-    }),
-    username: 'newuser',
-    deviceName: 'My Laptop',
-    ...overrides,
-  });
-
-  it('creates the account (signup branch) and commits the minted session', async () => {
-    const order: string[] = [];
-    const deps = buildDeps(order);
-
-    await runPasskeyRegister(deps);
-
-    expect(order).toEqual(['getRegisterOptions', 'runCeremony', 'registerVerify', 'commit']);
-    expect(deps.registerVerify).toHaveBeenCalledWith(
-      { id: 'attestation' },
-      { username: 'newuser', deviceName: 'My Laptop' },
-    );
-    expect(deps.commit).toHaveBeenCalledWith(expectedCommitInput);
-  });
-
-  it('throws (no commit) when verify returns a link branch instead of a session', async () => {
-    const order: string[] = [];
-    const deps = buildDeps(order, {
-      registerVerify: jest.fn(async () => linkResult),
-    });
-
-    await expect(runPasskeyRegister(deps)).rejects.toThrow(/did not establish a session/i);
-    expect(deps.commit).not.toHaveBeenCalled();
-  });
-
-  it('throws and touches nothing when passkeys are unsupported', async () => {
-    const order: string[] = [];
-    const deps = buildDeps(order, { isSupported: jest.fn(() => false) });
-
-    await expect(runPasskeyRegister(deps)).rejects.toThrow(PASSKEY_UNSUPPORTED_MESSAGE);
-    expect(deps.getRegisterOptions).not.toHaveBeenCalled();
-    expect(deps.commit).not.toHaveBeenCalled();
-  });
-});
-
 describe('runPasskeyAdd', () => {
   const buildDeps = (
     order: string[],

package/src/ui/context/hooks/useAuthOperations.ts

@@ -2,6 +2,7 @@ import { useCallback } from 'react';
 import type { ApiError, AuthStateStore, IdentityBinding, SessionClient, User } from '@oxy.so/core';
 import type { ClientSession, SessionLoginResponse } from '@oxy.so/core';
 import type { OxyRuntime } from '../../runtime';
+import type { LogoutResult } from '../oxyContextTypes';
 import { DeviceManager } from '@oxy.so/core';
 import { fetchSessionsWithFallback } from '../../utils/sessionHelpers';
 import { handleAuthError, isInvalidSessionError } from '../../utils/errorHandlers';
@@ -56,8 +57,8 @@ export interface UseAuthOperationsOptions {
 export interface UseAuthOperationsResult {
   /** Sign in with existing public key */
   signIn: (publicKey: string, deviceName?: string) => Promise<User>;
-  /** Logout from current session */
-  logout: (targetSessionId?: string) => Promise<void>;
+  /** Logout from current session. Never rejects — see {@link LogoutResult}. */
+  logout: (targetSessionId?: string) => Promise<LogoutResult>;
   /** Logout from all sessions */
   logoutAll: () => Promise<void>;
 }
@@ -292,9 +293,9 @@ export const useAuthOperations = ({
    * Logout from session
    */
   const logout = useCallback(
-    async (targetSessionId?: string): Promise<void> => {
+    async (targetSessionId?: string): Promise<LogoutResult> => {
       const activeSessionId = runtime.getSnapshot().activeSessionId;
-      if (!activeSessionId) return;
+      if (!activeSessionId) return { status: 'signed-out' };
 
       const sessionToLogout = targetSessionId || activeSessionId;
 
@@ -326,6 +327,7 @@ export const useAuthOperations = ({
           clearPersistedAuthSafe(store, logger);
           await clearSessionState();
         }
+        return { status: 'signed-out' };
       } catch (error) {
         const isInvalid = isInvalidSessionError(error);
 
@@ -337,7 +339,7 @@ export const useAuthOperations = ({
           // The active session is invalid → full sign-out; clear persisted state.
           clearPersistedAuthSafe(store, logger);
           await clearSessionState();
-          return;
+          return { status: 'signed-out' };
         }
 
         handleAuthError(error, {
@@ -348,6 +350,9 @@ export const useAuthOperations = ({
           logger,
           status: isInvalid ? 401 : undefined,
         });
+        // Nothing was revoked and the session is still installed here. Say so,
+        // rather than letting a caller close its surface as if it had worked.
+        return { status: 'failed', error };
       }
     },
     [

package/src/ui/context/oxyContextTypes.ts

@@ -11,6 +11,19 @@ import type {
 import type { WebAuthMode, WebOAuthSignInResult } from '../oauth/types';
 import type { StorageInterface } from '../utils/storageHelpers';
 
+/**
+ * The outcome of `logout()`. It never rejects: a caller reads this instead.
+ *
+ *  - `signed-out` — the server confirmed the sign-out, or the session was
+ *    already invalid and was cleaned up locally. Either way, this device no
+ *    longer holds it.
+ *  - `failed` — the revocation did not go through (typically no connection).
+ *    The session is still installed on this device, and nothing about the
+ *    outcome may be presented as revoked. The error is also reported through
+ *    the provider's `onError`, as before.
+ */
+export type LogoutResult = { status: 'signed-out' } | { status: 'failed'; error: unknown };
+
 export interface OxyContextState {
   user: User | null;
   sessions: ClientSession[];
@@ -75,12 +88,6 @@ export interface OxyContextState {
     deviceFingerprint?: string;
   }) => Promise<void>;
 
-  /**
-   * Create a brand-new account whose first authentication method is a passkey.
-   * WEB-ONLY — throws on native or an unsupported browser.
-   */
-  registerWithPasskey: (params: { username: string; deviceName?: string }) => Promise<void>;
-
   /**
    * Add a passkey to the already-signed-in account (bearer present). Does NOT
    * commit a new session; refreshes the linked auth-methods list on success.
@@ -125,10 +132,11 @@ export interface OxyContextState {
    */
   requestOAuthConsent: (options: RequestOAuthConsentOptions) => Promise<OAuthConsentResult>;
 
-  logout: (targetSessionId?: string) => Promise<void>;
+  logout: (targetSessionId?: string) => Promise<LogoutResult>;
   logoutAll: () => Promise<void>;
   switchSession: (sessionId: string) => Promise<User>;
-  removeSession: (sessionId: string) => Promise<void>;
+  /** The same operation as `logout(sessionId)`, with the same {@link LogoutResult}. */
+  removeSession: (sessionId: string) => Promise<LogoutResult>;
   refreshSessions: () => Promise<void>;
   setLanguage: (languageId: string) => Promise<void>;
   getDeviceSessions: () => Promise<

package/src/ui/context/passkeyFlow.ts

@@ -4,11 +4,11 @@
  * Extracted from `OxyContext` so the fixed `options → ceremony → verify → commit`
  * ordering is unit-testable with injected deps — the exact pattern
  * `commitSessionFlow.ts` (`commitDeviceSetAndResolve`) uses. The context methods
- * (`signInWithPasskey` / `registerWithPasskey` / `addPasskey`) are thin wrappers
+ * (`signInWithPasskey` / `addPasskey`) are thin wrappers
  * that supply the real deps: the core `webauthn*` methods, the platform ceremony
  * client (`webauthn/passkeyClient`), and the internal `commitSession` funnel.
  *
- * All three GATE on `isSupported()` first (the platform client returns `false`
+ * Both GATE on `isSupported()` first (the platform client returns `false`
  * off the web) so an unsupported surface fails loudly before touching a ceremony.
  */
 
@@ -84,43 +84,6 @@ export async function runPasskeyLogin(deps: RunPasskeyLoginDeps): Promise<void>
   await deps.commit(toCommitInput(result));
 }
 
-/** Injected dependencies for {@link runPasskeyRegister}. */
-export interface RunPasskeyRegisterDeps {
-  isSupported: () => boolean;
-  getRegisterOptions: (username: string) => Promise<unknown>;
-  runCeremony: (optionsJSON: unknown) => Promise<unknown>;
-  registerVerify: (
-    response: unknown,
-    envelope: { username: string; deviceName?: string },
-  ) => Promise<PasskeyRegisterVerifyResult>;
-  commit: (input: CommitInput) => Promise<void>;
-  username: string;
-  deviceName?: string;
-}
-
-/**
- * Passkey SIGNUP: create a brand-new account whose first auth method is a
- * passkey. The verify signup branch mints a session (a {@link LoginSessionResult}
- * carrying `sessionId`), which is committed exactly like a password signup.
- */
-export async function runPasskeyRegister(deps: RunPasskeyRegisterDeps): Promise<void> {
-  if (!deps.isSupported()) {
-    throw new Error(PASSKEY_UNSUPPORTED_MESSAGE);
-  }
-  const options = await deps.getRegisterOptions(deps.username);
-  const response = await deps.runCeremony(options);
-  const result = await deps.registerVerify(response, {
-    username: deps.username,
-    deviceName: deps.deviceName,
-  });
-  // Only the signup session arm carries `sessionId`; the link branch
-  // (`{ success, message }`) does not.
-  if (!('sessionId' in result)) {
-    throw new Error('Passkey registration did not establish a session.');
-  }
-  await deps.commit(toCommitInput(result));
-}
-
 /** Injected dependencies for {@link runPasskeyAdd}. */
 export interface RunPasskeyAddDeps {
   isSupported: () => boolean;

package/src/ui/hooks/accountDialogSnapshot.ts

@@ -27,11 +27,13 @@ export const EMPTY_ACCOUNT_DIALOG_SNAPSHOT: AccountDialogSnapshot = {
     qrPayload: null,
     expiresAt: null,
     error: null,
+    failure: null,
     route: null,
     routeFailed: false,
     pushSentAt: null,
     openedAt: null,
     progress: 'idle',
+    attempt: 0,
   },
   commonsAvailability: 'unknown',
 };

package/src/ui/hooks/useProfileEditing.ts

@@ -31,6 +31,7 @@ export interface ProfileUpdateData {
     phone?: string;
     address?: string;
     birthday?: string;
+    dateOfBirth?: string;
 }
 
 type ProfileFieldValue = string | ProfileLocation[] | ProfileLinkMetadata[];
@@ -87,6 +88,13 @@ export const useProfileEditing = () => {
         if (updates.birthday !== undefined) {
             updateData.birthday = updates.birthday;
         }
+        if (updates.dateOfBirth !== undefined) {
+            // '' clears it — `updateData.dateOfBirth` is `string | null`
+            // per the contract, and there is no separate blank sentinel for
+            // a structured date the way `blankToNull` gives every free-text
+            // field.
+            updateData.dateOfBirth = updates.dateOfBirth === '' ? null : updates.dateOfBirth;
+        }
 
         // Handle name field
         if (updates.firstName !== undefined || updates.lastName !== undefined) {
@@ -142,6 +150,13 @@ export const useProfileEditing = () => {
                 if (typeof value !== 'string') return false;
                 updates.birthday = value;
                 break;
+            case 'dateOfBirth':
+                // '' clears it (the picker's "no complete date selected"
+                // state) — `updateUserProfile`'s `dateOfBirth` block treats
+                // an empty string the same as `null`.
+                if (typeof value !== 'string') return false;
+                updates.dateOfBirth = value;
+                break;
             case 'location':
                 if (!isProfileLocationArray(value)) return false;
                 updates.locations = value;