@oxy.so/core 1.2.1 → 1.3.0

package/dist/esm/crypto/identityMove.js

@@ -0,0 +1,110 @@
+/**
+ * Identity move — the crypto of taking a web identity into Commons.
+ *
+ * Both carriers run this: `id.oxy.so` (the initiator, holding the identity) and
+ * Commons (the responder, receiving it). The relay in between sees two ephemeral
+ * public keys and ciphertext; the 6-digit SAS both screens show is what makes a
+ * relay that swapped a key visible to the person.
+ *
+ * PURE: no storage, no network. Contract: `@oxy.so/contracts` `identityMove`.
+ */
+import './polyfill.js';
+import { entropyToMnemonic, mnemonicToEntropy } from '@scure/bip39';
+import { wordlist } from '@scure/bip39/wordlists/english';
+import { bytesToHex, hexToBytes, utf8ToBytes } from '@noble/hashes/utils';
+import { signMessage, verifySignature } from '@oxy.so/protocol';
+import { generateSecp256k1KeyPair } from '@oxy.so/protocol/secp256k1';
+import { IDENTITY_MOVE_QR_PREFIX } from '@oxy.so/contracts';
+import { decryptAead, encryptAead, AEAD_KEY_LENGTH } from './aead.js';
+import { deriveSharedSecret } from './ecdh.js';
+import { hkdfSha256 } from './kdf.js';
+import { deriveIdentityFromMnemonic, deriveTransferSas, wipeBytes } from './webIdentityCarrier.js';
+const MOVE_KDF_INFO = utf8ToBytes('oxy-identity-move-v1');
+/** Actions the identity key signs during a move. */
+export const IDENTITY_MOVE_ACTIONS = {
+    seal: 'identity_move_seal',
+    received: 'identity_move_received',
+};
+/** A fresh ephemeral key pair for one move. Keep the private key in memory only. */
+export function generateMoveEphemeralKeyPair() {
+    return generateSecp256k1KeyPair();
+}
+/** The symmetric key both sides derive: HKDF(ECDH, salt = moveId). */
+export function deriveMoveKey(ownEphemeralPrivateKey, otherEphemeralPublicKey, moveId) {
+    const shared = deriveSharedSecret(ownEphemeralPrivateKey, otherEphemeralPublicKey);
+    try {
+        return hkdfSha256(shared, utf8ToBytes(moveId.toLowerCase()), MOVE_KDF_INFO, AEAD_KEY_LENGTH);
+    }
+    finally {
+        wipeBytes(shared);
+    }
+}
+/** The 6-digit code both screens show, bound to the move and both ephemeral keys in their roles. */
+export function deriveMoveSas(moveId, initiatorEphemeralPublicKey, responderEphemeralPublicKey) {
+    return deriveTransferSas({ pairingId: moveId, initiatorEphemeralPublicKey, responderEphemeralPublicKey });
+}
+function moveAad(moveId, publicKey) {
+    return utf8ToBytes(JSON.stringify({ v: 1, purpose: 'identity-move', moveId: moveId.toLowerCase(), publicKey: publicKey.toLowerCase() }));
+}
+/** Initiator: seal the identity's entropy for the responder. */
+export function sealIdentityForMove(identity, moveKey, moveId) {
+    const entropy = mnemonicToEntropy(identity.mnemonic, wordlist);
+    try {
+        const { nonce, ciphertext } = encryptAead(moveKey, entropy, moveAad(moveId, identity.publicKey));
+        return { nonce: bytesToHex(nonce), ciphertext: bytesToHex(ciphertext) };
+    }
+    finally {
+        wipeBytes(entropy);
+    }
+}
+/**
+ * Responder: open the sealed identity. The derived public key must be the one
+ * the move declared — anything else is refused, never imported.
+ */
+export function openMovedIdentity(sealed, moveKey, moveId, expectedPublicKey) {
+    let entropy;
+    try {
+        entropy = decryptAead(moveKey, hexToBytes(sealed.nonce), hexToBytes(sealed.ciphertext), moveAad(moveId, expectedPublicKey));
+    }
+    catch {
+        throw new Error('The identity could not be opened. The codes may not have matched — start again.');
+    }
+    try {
+        const identity = deriveIdentityFromMnemonic(entropyToMnemonic(entropy, wordlist));
+        if (identity.publicKey !== expectedPublicKey.toLowerCase()) {
+            throw new Error('The received identity is not the one being moved');
+        }
+        return identity;
+    }
+    finally {
+        wipeBytes(entropy);
+    }
+}
+/** The exact bytes a move proof or receipt signs. */
+export function buildMoveMessage(action, moveId, timestamp) {
+    return JSON.stringify({ action, moveId: moveId.toLowerCase(), timestamp });
+}
+/** Sign a move action with the identity key. */
+export async function signMoveAction(identity, action, moveId, timestamp = Date.now()) {
+    return { signature: await signMessage(buildMoveMessage(action, moveId, timestamp), identity.privateKey), timestamp };
+}
+/**
+ * Initiator: is this receipt really from the identity? Checked locally with the
+ * identity's public key, so a server that claims "completed" without Commons
+ * having the key cannot make the web destroy its copy.
+ */
+export function verifyMoveReceipt(publicKey, moveId, receipt) {
+    return verifySignature(buildMoveMessage(IDENTITY_MOVE_ACTIONS.received, moveId, receipt.timestamp), receipt.signature, publicKey);
+}
+/** The QR payload for a move. */
+export function buildMoveQrPayload(moveId) {
+    return `${IDENTITY_MOVE_QR_PREFIX}${moveId.toLowerCase()}`;
+}
+/** The move id in a scanned payload, or `null` when it is not a move QR. */
+export function parseMoveQrPayload(raw) {
+    const value = raw.trim();
+    if (!value.toLowerCase().startsWith(IDENTITY_MOVE_QR_PREFIX))
+        return null;
+    const id = value.slice(IDENTITY_MOVE_QR_PREFIX.length).toLowerCase();
+    return /^[0-9a-f]{32}$/.test(id) ? id : null;
+}

package/dist/esm/crypto/keyManager.js

@@ -746,6 +746,42 @@ export class KeyManager {
             return null;
         }
     }
+    /**
+     * Which identity key this device is actually acting as, per slot.
+     *
+     * There are two slots and they can disagree. The shared slot is what every
+     * cross-app reader takes first — `deriveScopedSeed` (so: the FairCoin wallet
+     * Peable derives) and `getSharedPrivateKey` — while the primary slot is what
+     * signing and the server-facing identity use. A disagreement is invisible to
+     * both sides on its own, and it is money: a wallet derived from a stale
+     * shared key watches addresses that the key published in the DID will never
+     * produce, so payments land where the recipient cannot see them.
+     *
+     * `activePublicKey` is the one money derives from — the same `shared ?? primary`
+     * order `deriveScopedSeed` uses, so a caller can compare it against the key
+     * published for the account and refuse to receive rather than watch the wrong
+     * addresses.
+     *
+     * Public keys are canonicalized, so two encodings of the same key compare
+     * equal. On web both slots are null and `inSync` is true: nothing is stored,
+     * so nothing can disagree.
+     */
+    static async getIdentityKeyState() {
+        const [primaryRaw, sharedRaw] = await Promise.all([
+            KeyManager.getPublicKey(),
+            KeyManager.getSharedPublicKey(),
+        ]);
+        const primaryPublicKey = primaryRaw ? KeyManager.canonicalPublicKey(primaryRaw) : null;
+        const sharedPublicKey = sharedRaw ? KeyManager.canonicalPublicKey(sharedRaw) : null;
+        return {
+            primaryPublicKey,
+            sharedPublicKey,
+            activePublicKey: sharedPublicKey ?? primaryPublicKey,
+            // Only a real disagreement is out of sync. A device with just one slot
+            // populated has nothing to contradict.
+            inSync: primaryPublicKey === null || sharedPublicKey === null || primaryPublicKey === sharedPublicKey,
+        };
+    }
     /**
      * Check if a shared identity exists (accessible across all Oxy apps)
      *
@@ -939,49 +975,52 @@ export class KeyManager {
         }
     }
     /**
-     * Migrate local identity to shared identity
+     * Make the shared slot hold THIS device's identity key.
      *
-     * Call this when upgrading existing apps to use shared identities.
-     * Copies the device-specific identity to shared storage so it can
-     * be accessed by other Oxy apps.
+     * The shared slot is the one every Oxy app on the device reads, so it has to
+     * agree with the primary slot. This creates it when it is empty (the original
+     * migration, for apps that predate the shared identity) and repairs it when it
+     * holds a different key.
      *
-     * @returns True if migration was successful, false if no local identity exists
+     * @returns True when the shared slot ends up holding the device's key, false
+     *          when there is no identity to share.
      */
-    static async migrateToSharedIdentity() {
+    static async syncSharedIdentity() {
         if (isWebPlatform()) {
             return false;
         }
         try {
-            // Check if we already have a shared identity
-            const hasShared = await KeyManager.hasSharedIdentity();
-            if (hasShared) {
-                if (isDev()) {
-                    logger.debug('Shared identity already exists, skipping migration', { component: 'KeyManager' });
-                }
+            const state = await KeyManager.getIdentityKeyState();
+            if (state.sharedPublicKey !== null && (state.inSync || state.primaryPublicKey === null)) {
                 return true;
             }
-            // Get local identity
             const privateKey = await KeyManager.getPrivateKey();
             if (!privateKey) {
-                if (isDev()) {
-                    logger.debug('No local identity to migrate', { component: 'KeyManager' });
-                }
-                return false;
+                // Nothing of this device's own to share. A shared slot that is already
+                // populated stays as it is: it is the only identity here.
+                return state.sharedPublicKey !== null;
             }
-            // Import to shared storage
             await KeyManager.importSharedIdentity(privateKey);
-            if (isDev()) {
-                logger.debug('Successfully migrated local identity to shared identity', { component: 'KeyManager' });
+            // A slot that held a DIFFERENT key is the dangerous case, so it is said
+            // out loud rather than debug-logged: until this write, cross-app readers
+            // (`deriveScopedSeed`, so Peable's wallet) were deriving from one key
+            // while signing and the server used another.
+            if (state.sharedPublicKey !== null) {
+                logger.warn('Shared identity held a different key than this device: repaired it from the primary slot.', { component: 'KeyManager', method: 'syncSharedIdentity' });
             }
             return true;
         }
         catch (error) {
             if (isDev()) {
-                logger.error('Failed to migrate to shared identity', error, { component: 'KeyManager' });
+                logger.error('Failed to sync the shared identity', error, { component: 'KeyManager' });
             }
             return false;
         }
     }
+    /** @deprecated Renamed to {@link KeyManager.syncSharedIdentity}. */
+    static async migrateToSharedIdentity() {
+        return KeyManager.syncSharedIdentity();
+    }
     // ==================== END SHARED IDENTITY METHODS ====================
     /**
      * Atomically persist a key pair to secure storage with verification + backup.

package/dist/esm/crypto/webIdentityCarrier.js

@@ -0,0 +1,243 @@
+/**
+ * Web identity carrier — the crypto of "one identity, two carriers".
+ *
+ * An Oxy identity is a BIP-39 mnemonic; its seed's first 32 bytes are the
+ * secp256k1 key (`recoveryPhrase.ts`). Commons keeps that key in the device
+ * keychain. This module lets a browser carry the SAME identity without Oxy ever
+ * being able to use it:
+ *
+ *   entropy ──AEAD(DEK)──▶ sealedEntropy
+ *   DEK     ──AEAD(KEK_i)─▶ wraps[i]            KEK_i = HKDF(PRF output of passkey i)
+ *
+ * The PRF output is produced inside the user's authenticator, behind user
+ * verification, and never leaves the page that asked for it. The envelope is
+ * therefore safe to store anywhere — the identity origin's IndexedDB and the
+ * server copy alike — and opens only with a registered passkey or the phrase.
+ *
+ * PURE: no storage, no network, no WebAuthn call, no platform globals beyond the
+ * CSPRNG the AEAD polyfill guarantees. The caller runs the ceremony and hands the
+ * PRF output in; everything here is deterministic given its inputs, so it is
+ * identical on web, Node and React Native, and fully unit-testable.
+ *
+ * Contract: `WebIdentityEnvelope` in `@oxy.so/contracts`.
+ */
+import './polyfill.js';
+import { entropyToMnemonic, generateMnemonic, mnemonicToEntropy, mnemonicToSeedSync, validateMnemonic } from '@scure/bip39';
+import { wordlist } from '@scure/bip39/wordlists/english';
+import { sha256 } from '@noble/hashes/sha256';
+import { bytesToHex, hexToBytes, utf8ToBytes } from '@noble/hashes/utils';
+import { signMessage } from '@oxy.so/protocol';
+import { deriveSecp256k1PublicKey } from '@oxy.so/protocol/secp256k1';
+import { WEB_IDENTITY_ENVELOPE_VERSION, } from '@oxy.so/contracts';
+import { AEAD_KEY_LENGTH, decryptAead, encryptAead } from './aead.js';
+import { hkdfSha256 } from './kdf.js';
+/**
+ * The PRF input every identity-carrier ceremony evaluates (`prf.eval.first`).
+ *
+ * Fixed rather than per-wrap: discoverable sign-in has no credential list to key
+ * `evalByCredential` by, and each passkey's output is already distinct. A future
+ * scheme change bumps the label — and with it every KEK — instead of mutating it.
+ */
+export const WEB_IDENTITY_PRF_INPUT = sha256(utf8ToBytes('oxy-web-identity-carrier/prf/v1'));
+/** HKDF salt of the key-encryption-key schedule. Versioned with the envelope. */
+const KEK_SALT = utf8ToBytes('oxy-web-identity-carrier/kek/v1');
+/** A WebAuthn PRF output is 32 bytes (HMAC-SHA-256). */
+const PRF_OUTPUT_LENGTH = 32;
+export class WebIdentityUnlockError extends Error {
+    constructor(failure, message) {
+        super(message);
+        this.failure = failure;
+        this.name = 'WebIdentityUnlockError';
+    }
+}
+function aadFor(parts) {
+    return utf8ToBytes(JSON.stringify(parts));
+}
+function entropyAad(publicKey) {
+    return aadFor({ v: WEB_IDENTITY_ENVELOPE_VERSION, purpose: 'entropy', publicKey });
+}
+function wrapAad(publicKey, credentialId) {
+    return aadFor({ v: WEB_IDENTITY_ENVELOPE_VERSION, purpose: 'wrap', publicKey, credentialId });
+}
+/** Overwrite a buffer holding secret material. Best effort — JS gives no stronger guarantee. */
+export function wipeBytes(bytes) {
+    bytes.fill(0);
+}
+/**
+ * Derive the identity from a mnemonic exactly as Commons does
+ * (`RecoveryPhraseService`): seed → first 32 bytes → secp256k1.
+ */
+export function deriveIdentityFromMnemonic(mnemonic) {
+    const normalized = mnemonic.trim().toLowerCase().split(/\s+/).join(' ');
+    if (!validateMnemonic(normalized, wordlist)) {
+        throw new Error('Invalid recovery phrase');
+    }
+    const seed = mnemonicToSeedSync(normalized);
+    const privateKeyBytes = seed.slice(0, 32);
+    wipeBytes(seed);
+    const privateKey = bytesToHex(privateKeyBytes);
+    wipeBytes(privateKeyBytes);
+    return { mnemonic: normalized, privateKey, publicKey: deriveSecp256k1PublicKey(privateKey) };
+}
+/** A brand-new 12-word identity. Nothing is persisted. */
+export function generateWebIdentity() {
+    return deriveIdentityFromMnemonic(generateMnemonic(wordlist, 128));
+}
+/** A fresh random data key for a new envelope. */
+export function generateDataKey() {
+    const key = new Uint8Array(AEAD_KEY_LENGTH);
+    globalThis.crypto.getRandomValues(key);
+    return key;
+}
+/** The key-encryption key a passkey's PRF output yields for its own wrap. */
+export function deriveKeyEncryptionKey(prfOutput, credentialId) {
+    if (prfOutput.length !== PRF_OUTPUT_LENGTH) {
+        throw new Error(`PRF output must be ${PRF_OUTPUT_LENGTH} bytes, got ${prfOutput.length}`);
+    }
+    return hkdfSha256(prfOutput, KEK_SALT, utf8ToBytes(credentialId), AEAD_KEY_LENGTH);
+}
+/** Wrap `dataKey` for one passkey. */
+export function wrapDataKey(dataKey, prfOutput, credentialId, publicKey, now = new Date()) {
+    const kek = deriveKeyEncryptionKey(prfOutput, credentialId);
+    try {
+        const { nonce, ciphertext } = encryptAead(kek, dataKey, wrapAad(publicKey, credentialId));
+        return {
+            credentialId,
+            nonce: bytesToHex(nonce),
+            wrappedKey: bytesToHex(ciphertext),
+            createdAt: now.toISOString(),
+        };
+    }
+    finally {
+        wipeBytes(kek);
+    }
+}
+/**
+ * Seal an identity into a new envelope that opens with the given passkey.
+ *
+ * Returns the data key too, so the caller can add further wraps in the same
+ * session; wipe it when done.
+ */
+export function sealWebIdentity(identity, firstWrap, now = new Date()) {
+    const derived = deriveIdentityFromMnemonic(identity.mnemonic);
+    if (derived.publicKey !== identity.publicKey.toLowerCase()) {
+        throw new Error('The recovery phrase does not belong to this identity');
+    }
+    const dataKey = generateDataKey();
+    const entropy = mnemonicToEntropy(derived.mnemonic, wordlist);
+    try {
+        const { nonce, ciphertext } = encryptAead(dataKey, entropy, entropyAad(derived.publicKey));
+        const envelope = {
+            version: WEB_IDENTITY_ENVELOPE_VERSION,
+            algorithm: 'xchacha20poly1305',
+            publicKey: derived.publicKey,
+            entropyNonce: bytesToHex(nonce),
+            sealedEntropy: bytesToHex(ciphertext),
+            wraps: [wrapDataKey(dataKey, firstWrap.prfOutput, firstWrap.credentialId, derived.publicKey, now)],
+        };
+        return { envelope, dataKey };
+    }
+    finally {
+        wipeBytes(entropy);
+    }
+}
+/** Recover the data key with one passkey's PRF output. */
+export function unwrapDataKey(envelope, prfOutput, credentialId) {
+    const wrap = envelope.wraps.find((entry) => entry.credentialId === credentialId);
+    if (!wrap) {
+        throw new WebIdentityUnlockError('unknown-credential', 'This passkey cannot open this identity');
+    }
+    const kek = deriveKeyEncryptionKey(prfOutput, credentialId);
+    try {
+        return decryptAead(kek, hexToBytes(wrap.nonce), hexToBytes(wrap.wrappedKey), wrapAad(envelope.publicKey, credentialId));
+    }
+    catch {
+        throw new WebIdentityUnlockError('prf-mismatch', 'This passkey returned a different secret than when it was registered');
+    }
+    finally {
+        wipeBytes(kek);
+    }
+}
+/**
+ * Open an envelope with its data key.
+ *
+ * The derived public key is checked against the envelope's own: a sealed entropy
+ * that decrypts into a different identity is treated as corruption, never used.
+ */
+export function openWebIdentity(envelope, dataKey) {
+    let entropy;
+    try {
+        entropy = decryptAead(dataKey, hexToBytes(envelope.entropyNonce), hexToBytes(envelope.sealedEntropy), entropyAad(envelope.publicKey));
+    }
+    catch {
+        throw new WebIdentityUnlockError('corrupt', 'The sealed identity could not be opened');
+    }
+    try {
+        const identity = deriveIdentityFromMnemonic(entropyToMnemonic(entropy, wordlist));
+        if (identity.publicKey !== envelope.publicKey.toLowerCase()) {
+            throw new WebIdentityUnlockError('corrupt', 'The sealed identity does not match its public key');
+        }
+        return identity;
+    }
+    finally {
+        wipeBytes(entropy);
+    }
+}
+/** Unwrap and open in one step. */
+export function unlockWebIdentity(envelope, prfOutput, credentialId) {
+    const dataKey = unwrapDataKey(envelope, prfOutput, credentialId);
+    try {
+        return openWebIdentity(envelope, dataKey);
+    }
+    finally {
+        wipeBytes(dataKey);
+    }
+}
+/** Add (or replace) one passkey's wrap. Requires the data key of an unlocked envelope. */
+export function addWrap(envelope, dataKey, prfOutput, credentialId, now = new Date()) {
+    // Proves `dataKey` belongs to THIS envelope before anything new can open it.
+    openWebIdentity(envelope, dataKey);
+    const others = envelope.wraps.filter((entry) => entry.credentialId !== credentialId);
+    return {
+        ...envelope,
+        wraps: [...others, wrapDataKey(dataKey, prfOutput, credentialId, envelope.publicKey, now)],
+    };
+}
+/** Remove one passkey's wrap. The last wrap can never be removed — an envelope nobody can open is a loss. */
+export function removeWrap(envelope, credentialId) {
+    const remaining = envelope.wraps.filter((entry) => entry.credentialId !== credentialId);
+    if (remaining.length === 0) {
+        throw new Error('An identity envelope must keep at least one passkey');
+    }
+    return { ...envelope, wraps: remaining };
+}
+/**
+ * The message an identity key signs to authorize an account action
+ * (`link_identity`, `web_envelope_delete`, …): `JSON.stringify({ action, userId,
+ * timestamp })`, byte-identical to what the API reconstructs.
+ */
+export function buildIdentityActionMessage(action, userId, timestamp) {
+    return JSON.stringify({ action, userId, timestamp });
+}
+/** Sign an identity-action message with an opened identity's key. */
+export async function signIdentityAction(identity, action, userId, timestamp = Date.now()) {
+    const signature = await signMessage(buildIdentityActionMessage(action, userId, timestamp), identity.privateKey);
+    return { signature, timestamp };
+}
+/**
+ * The 6-digit short authentication string both sides of an identity transfer show.
+ *
+ * Bound to the pairing and to BOTH ephemeral public keys in their roles, so a relay
+ * that substitutes either key produces a different code on each screen. The user
+ * comparing the two codes is what makes the transfer safe against the relay itself.
+ */
+export function deriveTransferSas(input) {
+    const digest = sha256(utf8ToBytes(JSON.stringify({
+        v: 'oxy-identity-transfer-sas-v1',
+        pairingId: input.pairingId.toLowerCase(),
+        initiator: input.initiatorEphemeralPublicKey.toLowerCase(),
+        responder: input.responderEphemeralPublicKey.toLowerCase(),
+    })));
+    const value = ((digest[0] << 24) | (digest[1] << 16) | (digest[2] << 8) | digest[3]) >>> 0;
+    return String(value % 1000000).padStart(6, '0');
+}

package/dist/esm/i18n/locales/ar-SA.json

@@ -52,19 +52,9 @@
     "signup": {
         "title": "أنشئ حسابك",
         "subtitle": "هوية واحدة لكل النظام البيئي.",
-        "commonsHeadline": "أنشئ هويتك في Commons",
-        "commonsExplainer": "‏Commons هي هوية Oxy الخاصة بك بحفظ ذاتي كامل — تطبيق واحد يعمل في كل مكان.",
         "createInCommons": "أنشئ هويتك في Commons",
-        "passkeyAlternative": "لا تملك Commons؟ أنشئ مفتاح مرور على هذا الجهاز بدلاً من ذلك",
         "createAccount": "إنشاء حساب",
-        "creating": "جارٍ الإنشاء…",
-        "usernamePlaceholder": "اختر اسم مستخدم",
-        "usernameChecking": "جارٍ التحقق…",
-        "usernameAvailable": "متاح",
-        "usernameTaken": "اسم المستخدم هذا مستخدم بالفعل",
         "backToSignInLink": "لديك حساب بالفعل؟ سجّل الدخول",
-        "hubExplainer": "أنشئ هوية Oxy الخاصة بك في نافذة آمنة، ثم عد إلى هنا مباشرة.",
-        "continueInWindow": "المتابعة في نافذة جديدة",
         "welcome": {
             "title": "مرحبًا بك في Oxy!",
             "subtitle": "أنشئ حسابك في خطوات قليلة",
@@ -119,7 +109,6 @@
         "qrHeadline": "سجّل الدخول بهوية Oxy الخاصة بك",
         "signInWithOxy": "تسجيل الدخول باستخدام Oxy",
         "useIdentityOnDevice": "لا تملك Commons؟ استخدم مفتاح مرور على هذا الجهاز بدلاً من ذلك",
-        "passkeySigningIn": "جارٍ تسجيل الدخول…",
         "getCommons": "احصل على Commons",
         "commonsNotInstalled": "لا تملك Commons؟ احصل على التطبيق لتسجيل الدخول بمعرّف Oxy الخاص بك.",
         "showQrAnyway": "لدي Commons على جهاز آخر",
@@ -136,7 +125,20 @@
             "openedInCommons": "تم الفتح في Commons",
             "confirming": "جارٍ تأكيد الهوية",
             "confirmed": "تم تأكيد الهوية"
-        }
+        },
+        "signInFailures": {
+            "denied": "تم رفض تسجيل الدخول في Commons.",
+            "expired": "انتهت صلاحية طلب تسجيل الدخول. يُرجى المحاولة مرة أخرى.",
+            "network": "تعذّر الاتصال بـ Oxy. تحقّق من اتصالك وحاول مرة أخرى.",
+            "notConfigured": "هذا التطبيق غير مُعدّ لتسجيل الدخول بعد.",
+            "unsupportedFlow": "لا يمكن إكمال تسجيل الدخول هنا.",
+            "claimFailed": "تمت الموافقة على تسجيل الدخول، لكن تعذّر إكماله. يُرجى المحاولة مرة أخرى.",
+            "generic": "تعذّر تسجيل الدخول. يُرجى المحاولة مرة أخرى."
+        },
+        "linkOpenFailed": "تعذّر فتح الرابط. يُرجى المحاولة مرة أخرى.",
+        "continueWithPasskey": "متابعة",
+        "passkeyHint": "استخدم بصمتك أو وجهك أو رمز PIN للجهاز.",
+        "otherDeviceCommons": "حسابك على جهاز آخر؟ امسح الرمز باستخدام Commons"
     },
     "common": {
         "actions": {
@@ -277,6 +279,7 @@
         "help": "المساعدة والملاحظات",
         "signOut": "تسجيل الخروج",
         "privacy": "سياسة الخصوصية",
-        "terms": "شروط الخدمة"
+        "terms": "شروط الخدمة",
+        "identity": "هويتك"
     }
 }

package/dist/esm/i18n/locales/ca-ES.json

@@ -52,19 +52,9 @@
     "signup": {
         "title": "Crea el teu compte",
         "subtitle": "Una identitat per a tot l'ecosistema.",
-        "commonsHeadline": "Crea la teva identitat a Commons",
-        "commonsExplainer": "Commons és la teva identitat d'Oxy amb autocustòdia completa: una app que funciona a tot arreu.",
         "createInCommons": "Crea la teva identitat a Commons",
-        "passkeyAlternative": "No tens Commons? Crea una clau d'accés en aquest dispositiu",
         "createAccount": "Crear compte",
-        "creating": "Creant…",
-        "usernamePlaceholder": "Tria un nom d'usuari",
-        "usernameChecking": "Comprovant…",
-        "usernameAvailable": "Disponible",
-        "usernameTaken": "Aquest nom d'usuari ja està en ús",
         "backToSignInLink": "Ja tens compte? Inicia sessió",
-        "hubExplainer": "Crea la teva Oxy ID en una finestra segura i torna de seguida.",
-        "continueInWindow": "Continua en una finestra nova",
         "welcome": {
             "title": "Benvingut a Oxy!",
             "subtitle": "Crea el teu compte en pocs passos",
@@ -119,7 +109,6 @@
         "qrHeadline": "Inicia sessió amb la teva identitat d'Oxy",
         "signInWithOxy": "Inicia sessió amb Oxy",
         "useIdentityOnDevice": "No tens Commons? Fes servir una clau d'accés en aquest dispositiu",
-        "passkeySigningIn": "Iniciant sessió…",
         "getCommons": "Descarrega Commons",
         "commonsNotInstalled": "No tens Commons? Descarrega l'app per iniciar sessió amb el teu Oxy ID.",
         "showQrAnyway": "Tinc Commons en un altre dispositiu",
@@ -136,7 +125,20 @@
             "openedInCommons": "Obert a Commons",
             "confirming": "Confirmant la identitat",
             "confirmed": "Identitat confirmada"
-        }
+        },
+        "signInFailures": {
+            "denied": "S'ha rebutjat l'inici de sessió a Commons.",
+            "expired": "La sol·licitud d'inici de sessió ha caducat. Torna-ho a provar.",
+            "network": "No s'ha pogut connectar amb Oxy. Comprova la connexió i torna-ho a provar.",
+            "notConfigured": "Aquesta app encara no està preparada per iniciar sessió.",
+            "unsupportedFlow": "Aquest inici de sessió no es pot completar aquí.",
+            "claimFailed": "S'ha aprovat l'inici de sessió, però no l'hem pogut completar. Torna-ho a provar.",
+            "generic": "No s'ha pogut iniciar la sessió. Torna-ho a provar."
+        },
+        "linkOpenFailed": "No s'ha pogut obrir l'enllaç. Torna-ho a provar.",
+        "continueWithPasskey": "Continua",
+        "passkeyHint": "Fes servir l'empremta, la cara o el PIN del dispositiu.",
+        "otherDeviceCommons": "El teu compte és en un altre dispositiu? Escaneja amb Commons"
     },
     "common": {
         "actions": {
@@ -277,6 +279,7 @@
         "help": "Ajuda i comentaris",
         "signOut": "Tancar sessió",
         "privacy": "Política de privacitat",
-        "terms": "Condicions del servei"
+        "terms": "Condicions del servei",
+        "identity": "La teva identitat"
     }
 }

package/dist/esm/i18n/locales/de-DE.json

@@ -52,19 +52,9 @@
     "signup": {
         "title": "Erstellen Sie Ihr Konto",
         "subtitle": "Eine Identität für das gesamte Ökosystem.",
-        "commonsHeadline": "Erstellen Sie Ihre Identität in Commons",
-        "commonsExplainer": "Commons ist Ihre vollständig selbstverwaltete Oxy-Identität – eine App, überall einsetzbar.",
         "createInCommons": "Erstellen Sie Ihre Identität in Commons",
-        "passkeyAlternative": "Kein Commons? Erstellen Sie stattdessen einen Passkey auf diesem Gerät",
         "createAccount": "Konto erstellen",
-        "creating": "Wird erstellt…",
-        "usernamePlaceholder": "Benutzernamen wählen",
-        "usernameChecking": "Wird geprüft…",
-        "usernameAvailable": "Verfügbar",
-        "usernameTaken": "Dieser Benutzername ist bereits vergeben",
         "backToSignInLink": "Sie haben bereits ein Konto? Anmelden",
-        "hubExplainer": "Erstellen Sie Ihre Oxy-ID in einem sicheren Fenster und kehren Sie dann direkt zurück.",
-        "continueInWindow": "In einem neuen Fenster fortfahren",
         "welcome": {
             "title": "Willkommen bei Oxy!",
             "subtitle": "Erstellen Sie Ihr Konto in nur wenigen Schritten",
@@ -119,7 +109,6 @@
         "qrHeadline": "Melden Sie sich mit Ihrer Oxy-Identität an",
         "signInWithOxy": "Mit Oxy anmelden",
         "useIdentityOnDevice": "Kein Commons? Verwenden Sie stattdessen einen Passkey auf diesem Gerät",
-        "passkeySigningIn": "Anmeldung läuft…",
         "getCommons": "Commons herunterladen",
         "commonsNotInstalled": "Kein Commons? Holen Sie sich die App, um sich mit Ihrer Oxy-ID anzumelden.",
         "showQrAnyway": "Ich habe Commons auf einem anderen Gerät",
@@ -136,7 +125,20 @@
             "openedInCommons": "In Commons geöffnet",
             "confirming": "Identität wird bestätigt",
             "confirmed": "Identität bestätigt"
-        }
+        },
+        "signInFailures": {
+            "denied": "Die Anmeldung wurde in Commons abgelehnt.",
+            "expired": "Die Anmeldeanfrage ist abgelaufen. Bitte versuchen Sie es erneut.",
+            "network": "Oxy ist nicht erreichbar. Prüfen Sie Ihre Verbindung und versuchen Sie es erneut.",
+            "notConfigured": "Diese App ist noch nicht für die Anmeldung eingerichtet.",
+            "unsupportedFlow": "Diese Anmeldung kann hier nicht abgeschlossen werden.",
+            "claimFailed": "Die Anmeldung wurde genehmigt, konnte aber nicht abgeschlossen werden. Bitte versuchen Sie es erneut.",
+            "generic": "Die Anmeldung ist fehlgeschlagen. Bitte versuchen Sie es erneut."
+        },
+        "linkOpenFailed": "Der Link konnte nicht geöffnet werden. Bitte versuchen Sie es erneut.",
+        "continueWithPasskey": "Weiter",
+        "passkeyHint": "Nutzen Sie Fingerabdruck, Gesicht oder die Geräte-PIN.",
+        "otherDeviceCommons": "Konto auf einem anderen Gerät? Mit Commons scannen"
     },
     "common": {
         "actions": {
@@ -277,6 +279,7 @@
         "help": "Hilfe & Feedback",
         "signOut": "Abmelden",
         "privacy": "Datenschutzerklärung",
-        "terms": "Nutzungsbedingungen"
+        "terms": "Nutzungsbedingungen",
+        "identity": "Ihre Identität"
     }
 }