@oxy.so/services 1.0.3 → 1.2.0

package/src/ui/components/OxyProvider.tsx

@@ -14,6 +14,7 @@ import { createMemoryStorage, createPlatformStorage, type StorageInterface } fro
 import { isNetConnectivityOnline } from '../utils/netConnectivity';
 import { KeyboardBoundary } from './KeyboardBoundary';
 import { ProductAnalyticsObserver } from '../analytics/productAnalytics';
+import { LanguageBridge } from './LanguageBridge';
 
 const bootStyles = StyleSheet.create({
     providerRoot: {
@@ -58,6 +59,20 @@ const isWeb = Platform.OS === 'web';
  *   return <Text>Welcome, {user?.username}!</Text>;
  * }
  * ```
+ *
+ * An app with its own translated UI passes a language config to follow the account's
+ * (or, signed out, the device/guest) resolved locale automatically — see ADR
+ * 0022 (`docs/adr/0022-app-i18n-follows-oxy-language.md`):
+ * ```tsx
+ * <OxyProvider
+ *   baseURL="https://api.oxy.so"
+ *   language={{
+ *     supportedLocales: SUPPORTED_LANGUAGES,       // this app's own catalog
+ *     fallbackLocale: DEFAULT_LANGUAGE,
+ *     onChange: (locale) => i18n.changeLanguage(locale),
+ *   }}
+ * >
+ * ```
  */
 const OxyProvider: FC<OxyProviderProps> = ({
     oxyServices,
@@ -76,6 +91,7 @@ const OxyProvider: FC<OxyProviderProps> = ({
     requireAuth = 'off',
     backgroundSession = false,
     deviceCredentialStorage = 'persistent',
+    language,
 }) => {
 
     // Storage + persistence wiring.
@@ -229,6 +245,7 @@ const OxyProvider: FC<OxyProviderProps> = ({
                 onAuthStateChange={onAuthStateChange as OxyRuntimeProviderProps['onAuthStateChange']}
             >
                 {productAnalytics ? <ProductAnalyticsObserver analytics={productAnalytics} /> : null}
+                {language ? <LanguageBridge {...language} /> : null}
                 <SurfaceProvider>
                     {requireAuth === 'off' ? (
                         children

package/src/ui/components/__tests__/LanguageBridge.test.tsx

@@ -0,0 +1,81 @@
+import React from 'react';
+import { render } from '@testing-library/react';
+import { LanguageBridge } from '../LanguageBridge';
+
+/**
+ * `OxyProvider`'s language config prop, realized: the one place Oxy's
+ * resolved language reaches a host app's own i18n library. `useOxy` is mocked here —
+ * it is the SDK's own well-tested context — so these tests exercise exactly
+ * what this component adds: coercion to the caller's catalog, and calling
+ * back only when the RESOLVED locale actually changes.
+ */
+
+let mockCurrentLanguage = 'en-US';
+jest.mock('../../context/OxyContext', () => ({
+  useOxy: () => ({ currentLanguage: mockCurrentLanguage }),
+}));
+
+const HOST_CATALOG = ['en-US', 'es-ES', 'fr-FR'] as const;
+
+beforeEach(() => {
+  mockCurrentLanguage = 'en-US';
+});
+
+it('resolves and reports the account language on mount', () => {
+  mockCurrentLanguage = 'es-ES';
+  const onChange = jest.fn();
+  render(<LanguageBridge supportedLocales={HOST_CATALOG} fallbackLocale="en-US" onChange={onChange} />);
+
+  expect(onChange).toHaveBeenCalledWith('es-ES');
+});
+
+it('coerces a locale the host never shipped a catalog for, by base language', () => {
+  mockCurrentLanguage = 'es-MX';
+  const onChange = jest.fn();
+  render(<LanguageBridge supportedLocales={HOST_CATALOG} fallbackLocale="en-US" onChange={onChange} />);
+
+  expect(onChange).toHaveBeenCalledWith('es-ES');
+});
+
+it('falls back to the caller default when nothing matches, even by base', () => {
+  mockCurrentLanguage = 'ja-JP';
+  const onChange = jest.fn();
+  render(<LanguageBridge supportedLocales={HOST_CATALOG} fallbackLocale="en-US" onChange={onChange} />);
+
+  expect(onChange).toHaveBeenCalledWith('en-US');
+});
+
+it('calls back again only when the RESOLVED locale changes', () => {
+  const onChange = jest.fn();
+  const { rerender } = render(
+    <LanguageBridge supportedLocales={HOST_CATALOG} fallbackLocale="en-US" onChange={onChange} />,
+  );
+  expect(onChange).toHaveBeenCalledTimes(1);
+
+  // Same resolved locale, brand-new callback identity (the common case for an
+  // inline arrow function) — must not re-fire.
+  rerender(<LanguageBridge supportedLocales={HOST_CATALOG} fallbackLocale="en-US" onChange={() => {}} />);
+  expect(onChange).toHaveBeenCalledTimes(1);
+
+  mockCurrentLanguage = 'fr-FR';
+  rerender(<LanguageBridge supportedLocales={HOST_CATALOG} fallbackLocale="en-US" onChange={onChange} />);
+  expect(onChange).toHaveBeenCalledTimes(2);
+  expect(onChange).toHaveBeenLastCalledWith('fr-FR');
+});
+
+it('reports a rejected onChange to onError instead of throwing', async () => {
+  const failure = new Error('catalog failed to load');
+  const onChange = jest.fn().mockRejectedValue(failure);
+  const onError = jest.fn();
+  render(
+    <LanguageBridge
+      supportedLocales={HOST_CATALOG}
+      fallbackLocale="en-US"
+      onChange={onChange}
+      onError={onError}
+    />,
+  );
+
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  expect(onError).toHaveBeenCalledWith(failure, 'en-US');
+});

package/src/ui/components/__tests__/OxyConsentScreen.test.tsx

@@ -24,6 +24,7 @@ function renderScreen(props: Partial<OxyConsentScreenProps> = {}) {
       application={props.application ?? baseApp}
       scopes={props.scopes ?? ['openid', 'profile']}
       user={props.user}
+      resource={props.resource}
       onAllow={props.onAllow ?? onAllow}
       onDeny={props.onDeny ?? onDeny}
       busy={props.busy}
@@ -138,6 +139,37 @@ describe('OxyConsentScreen', () => {
     expect(getByTestId('consent-account-name').textContent).toBe('Alice A');
   });
 
+  it('renders the exact MCP app, protected resource, account id and catalog-derived write actions', () => {
+    const { getByTestId } = renderScreen({
+      scopes: ['email.read', 'email.send'],
+      user: {
+        accountId: 'account-mail-1',
+        displayName: 'Oxy Mail',
+        handle: 'oxy-mail-account',
+      },
+      resource: {
+        application: { name: 'Inbox', iconUrl: 'inbox-icon' },
+        uri: 'https://mcp.inbox.oxy.so',
+        writeActions: [{
+          name: 'sendEmail',
+          version: '1.0.0',
+          description: 'Send an email from the selected mailbox.',
+          requiredCapabilities: ['email.send'],
+          effect: 'external',
+        }],
+      },
+    });
+
+    expect(getByTestId('consent-resource-app').textContent).toBe('Inbox');
+    expect(getByTestId('consent-resource-uri').textContent).toBe('https://mcp.inbox.oxy.so');
+    expect(getByTestId('consent-account-id').textContent).toContain('account-mail-1');
+    expect(getByTestId('consent-scope-email.send').textContent).toContain('email.send');
+    expect(getByTestId('consent-write-action-sendEmail').textContent).toContain(
+      'Send an email from the selected mailbox.',
+    );
+    expect(getByTestId('consent-write-action-sendEmail').textContent).toContain('External');
+  });
+
   it('falls back to the handle when the account has no display name (D5)', () => {
     const { getByTestId } = renderScreen({ user: { handle: 'bob' } });
     expect(getByTestId('consent-account-name').textContent).toBe('bob');

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

@@ -477,6 +477,13 @@ const AccountsMenuView: React.FC<AccountsMenuViewProps> = ({
           title={t('accountMenu.settings')}
           onPress={menu.onOpenSettings}
         />
+        {menu.onOpenIdentity ? (
+          <SettingsListItem
+            icon={<MenuIcon name="shield-account-outline" theme={theme} />}
+            title={t('accountMenu.identity')}
+            onPress={menu.onOpenIdentity}
+          />
+        ) : null}
         <SettingsListItem
           icon={<MenuIcon name="help-circle-outline" theme={theme} />}
           title={t('accountMenu.help')}

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

@@ -1,24 +1,24 @@
 /**
  * The sign-in ENTRY (`signin` / `add` views) — ONE primary action.
  *
- * Issue #691, Phase 5: the normal experience presents no menu of authentication
- * methods. The user sees "Continue with Oxy"; Oxy — not the user — then picks
- * how the request reaches their Commons identity, and the request surface shows
- * honest progress. Everything else (a QR from another device, a passkey on this
- * device, getting Commons, creating an account) lives behind "Having trouble?".
+ * Web: "Continue" opens the identity origin (`id.oxy.so`) in a popup, where the
+ * person signs in — or creates an account — with a passkey, and the account's
+ * self-custody identity is created or unsealed (one identity, two carriers). No
+ * philosophy up front: fingerprint, face or device PIN, and they are in. An
+ * account that lives on another device is one subordinate link away (Commons
+ * QR). Nothing auto-starts: a browser only opens a popup from a user gesture.
  *
- * Existing accounts still render ABOVE the CTA: "continue as one of these" is a
- * choice of WHO, not of HOW, so it is not one of the competing method buttons
- * the issue removes.
+ * Native: "Continue with Oxy" — the Commons flow (shared keychain, else the
+ * request Oxy routes to the person's Commons identity).
  *
- * On web this view is transient — the container auto-starts the flow the instant
- * the view is reached, because the request surface (QR, or "Check Commons on
- * your phone") IS the primary route there, never something behind a tap.
+ * Existing accounts still render ABOVE the CTA: "continue as one of these" is a
+ * choice of WHO, not of HOW.
  */
 
 import type React from 'react';
 import { View } from 'react-native';
 import { Button } from '@oxy.so/bloom/button';
+import { Text } from '@oxy.so/bloom/typography';
 import {
   showsPrincipalHeaders,
   type AccountDialogSnapshot,
@@ -42,7 +42,7 @@ interface SignInEntryViewProps {
   theme: Theme;
   t: Translate;
   handlers: OxyAuthChooserHandlers;
-  /** The ONE primary action. Starts the flow; Oxy chooses the route from there. */
+  /** Native's primary action. Starts the Commons flow; Oxy chooses the route from there. */
   onContinueWithOxy: () => void;
   alternatives: SignInAlternatives;
 }
@@ -56,37 +56,20 @@ const SignInEntryView: React.FC<SignInEntryViewProps> = ({
   onContinueWithOxy,
   alternatives,
 }) => {
-  // The entry has no chosen route yet, so nothing here can have failed: the
-  // alternatives stay behind the disclosure unconditionally.
-  const troubleActions: OxySignInSurfaceAction[] = [
-    {
-      key: 'scan-qr-link',
-      label: t('accountSwitcher.scanQr'),
-      onPress: alternatives.onShowQr,
-    },
-    ...(alternatives.passkeyAvailable
-      ? [
-          {
-            key: 'passkey-signin-link',
-            label: alternatives.passkeyPending
-              ? t('accountSwitcher.passkeySigningIn')
-              : t('accountSwitcher.useIdentityOnDevice'),
-            onPress: alternatives.onSignInWithPasskey,
-            disabled: alternatives.passkeyPending,
-          },
-        ]
-      : []),
-    {
-      key: 'get-commons-link',
-      label: t('accountSwitcher.getCommons'),
-      onPress: alternatives.onGetCommons,
-    },
-  ];
+  const web = alternatives.passkeyAvailable;
+
+  // Web keeps Commons one link away; native keeps its QR/Commons alternatives
+  // behind the disclosure, as before.
+  const troubleActions: OxySignInSurfaceAction[] = web
+    ? [{ key: 'get-commons-link', label: t('accountSwitcher.getCommons'), onPress: alternatives.onGetCommons }]
+    : [
+        { key: 'scan-qr-link', label: t('accountSwitcher.scanQr'), onPress: alternatives.onShowQr },
+        { key: 'get-commons-link', label: t('accountSwitcher.getCommons'), onPress: alternatives.onGetCommons },
+      ];
 
   // Whose route this is only needs naming when the list holds more than one
   // person, or somebody with more than one account — the same rule the account
-  // menu's group headers follow, so the two surfaces agree on when the actor is
-  // worth stating.
+  // menu's group headers follow.
   const namesTheOperator = showsPrincipalHeaders(principals);
   const rows = principals.flatMap((principal) =>
     principal.contexts.map((context) => ({
@@ -117,18 +100,23 @@ const SignInEntryView: React.FC<SignInEntryViewProps> = ({
         </View>
       ) : null}
 
+      {web ? (
+        <Text style={[styles.mutedText, { color: theme.colors.textSecondary }]}>
+          {t('accountSwitcher.passkeyHint')}
+        </Text>
+      ) : null}
+
       <Button
         variant="primary"
-        onPress={onContinueWithOxy}
+        onPress={web ? alternatives.onSignInWithPasskey : onContinueWithOxy}
         style={styles.primaryButton}
         testID="continue-with-oxy"
       >
-        {t('accountSwitcher.continueWithOxy')}
+        {web ? t('accountSwitcher.continueWithPasskey') : t('accountSwitcher.continueWithOxy')}
       </Button>
 
       {/* Account CREATION is not an authentication method — it is the way in for
-          someone who has no Oxy ID yet — so it keeps its own subordinate link
-          rather than hiding behind a troubleshooting affordance. */}
+          someone who has no account yet — so it keeps its own subordinate link. */}
       <SubtleLink
         label={t('signin.createAccountLink')}
         theme={theme}
@@ -136,6 +124,15 @@ const SignInEntryView: React.FC<SignInEntryViewProps> = ({
         testID="create-account-link"
       />
 
+      {web ? (
+        <SubtleLink
+          label={t('accountSwitcher.otherDeviceCommons')}
+          theme={theme}
+          onPress={alternatives.onShowQr}
+          testID="scan-qr-link"
+        />
+      ) : null}
+
       <TroubleDisclosure actions={troubleActions} revealed={false} theme={theme} t={t} />
     </View>
   );

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

@@ -58,11 +58,8 @@ const SignInRequestView: React.FC<SignInRequestViewProps> = ({
       ? [
           {
             key: 'passkey-signin-link',
-            label: alternatives.passkeyPending
-              ? t('accountSwitcher.passkeySigningIn')
-              : t('accountSwitcher.useIdentityOnDevice'),
+            label: t('accountSwitcher.useIdentityOnDevice'),
             onPress: alternatives.onSignInWithPasskey,
-            disabled: alternatives.passkeyPending,
           },
         ]
       : [];

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

@@ -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);