pgkiln 0.60.0 → 0.62.0

package/src/builder/i18n/fr.ts

@@ -1714,16 +1714,16 @@ export const fr: BuilderMessages = {
   // ------------------------------------------------------------ Security: two-factor sign-in (sprint 126)
   'mfa.menu': 'Connexion à deux facteurs',
   'mfa.title': 'Sécurité',
-  'mfa.intro': 'Connectez-vous avec un code d’une application d’authentification après votre mot de passe. Les codes de récupération vous laissent entrer si vous perdez le téléphone.',
-  'mfa.required_you': 'Votre administrateur exige la connexion à deux facteurs : ajoutez une application d’authentification.',
+  'mfa.intro': 'Après votre mot de passe, confirmez que c’est vous avec une clé d’accès (empreinte, visage, clé de sécurité) ou un code d’une application d’authentification. Les codes de récupération vous laissent entrer si vous les perdez.',
+  'mfa.required_you': 'Votre administrateur exige la connexion à deux facteurs : ajoutez une clé d’accès ou une application d’authentification.',
   'mfa.banner': 'La connexion à deux facteurs est obligatoire. Configurez-la avant le {date} : {link}',
   'mfa.set_up_now': 'configurer maintenant',
-  'mfa.apps': 'Applications d’authentification',
+  'mfa.factors': 'Clés d’accès et applications d’authentification',
   'mfa.app_name': 'Nom',
   'mfa.app_default': 'Téléphone',
   'mfa.added': 'Ajoutée',
   'mfa.last_used': 'Dernière utilisation',
-  'mfa.no_apps': 'Pas encore d’application d’authentification : vous vous connectez avec votre mot de passe seul.',
+  'mfa.no_apps': 'Pas encore de second facteur : vous vous connectez avec votre mot de passe seul.',
   'mfa.add_app': 'Ajouter une application d’authentification',
   'mfa.no_key': 'La connexion à deux facteurs a besoin de la clé de l’instance (PGKILN_SECRET_KEY) pour stocker le secret de l’application.',
   'mfa.scan': 'Scannez le code QR avec une application d’authentification.',
@@ -1739,28 +1739,28 @@ export const fr: BuilderMessages = {
   'mfa.remove_app': 'Supprimer cette application',
   'mfa.your_password': 'Votre mot de passe',
   'mfa.wrong_password': 'Mot de passe incorrect.',
-  'mfa.cannot_remove_required': 'La connexion à deux facteurs est obligatoire pour vous : ajoutez une autre application avant de supprimer celle-ci.',
+  'mfa.cannot_remove_required': 'La connexion à deux facteurs est obligatoire pour vous : ajoutez une autre clé ou application avant de supprimer celle-ci.',
   'mfa.cannot_remove_admin': 'Au moins deux administrateurs (ou tous, s’ils sont moins nombreux) doivent garder la connexion à deux facteurs tant que la règle est active.',
   'mfa.keep_admins': 'Pas maintenant : la règle à deux facteurs exige au moins deux administrateurs avec la connexion à deux facteurs (ou tous, s’ils sont moins nombreux).',
-  'mfa.removed': 'Application d’authentification supprimée.',
+  'mfa.removed': 'Supprimé.',
   'mfa.codes_title': 'Codes de récupération',
   'mfa.codes_once': 'Conservez ces codes en lieu sûr, loin de votre téléphone. Chacun remplace une fois un code de l’application. Ils ne sont affichés que maintenant.',
   'mfa.codes_saved': 'J’ai conservé ces codes',
   'mfa.codes_done': 'Terminé',
   'mfa.codes_kept': 'Codes de récupération conservés.',
   'mfa.codes_left': 'Codes de récupération inutilisés : {n}.',
-  'mfa.codes_after': 'Vous recevez des codes de récupération en ajoutant une application d’authentification.',
+  'mfa.codes_after': 'Vous recevez des codes de récupération en ajoutant une clé d’accès ou une application d’authentification.',
   'mfa.codes_low': 'Il reste peu de codes de récupération : créez-en de nouveaux.',
   'mfa.codes_new': 'Nouveaux codes de récupération',
   'mfa.codes_new_confirm': 'Créer de nouveaux codes de récupération ? Les anciens ne fonctionneront plus.',
   'mfa.expired': 'La connexion a pris trop de temps : reconnectez-vous.',
   'mfa.step_title': 'Connexion à deux facteurs',
-  'mfa.step_intro': 'Saisissez le code de votre application d’authentification pour {user}.',
+  'mfa.step_intro': 'Confirmez que c’est vous, {user} : utilisez une clé d’accès ou saisissez un code de votre application d’authentification.',
   'mfa.code': 'Code',
   'mfa.code_help': '6 chiffres de l’application, ou l’un de vos codes de récupération.',
   'mfa.verify': 'Vérifier',
   'mfa.cancel': 'Retour à la connexion',
-  'mfa.locked_out': 'Téléphone et codes perdus ? Demandez à un administrateur de réinitialiser votre connexion à deux facteurs.',
+  'mfa.locked_out': 'Téléphone, clé et codes perdus ? Demandez à un administrateur de réinitialiser votre connexion à deux facteurs.',
   'mfa.wrong': 'Ce code est incorrect ou a déjà été utilisé.',
   'mfa.column': 'Deux facteurs',
   'mfa.on': 'activée',
@@ -1784,4 +1784,40 @@ export const fr: BuilderMessages = {
   'mfa.policy_needs_admins': 'D’abord, au moins deux administrateurs (ou tous, s’ils sont moins nombreux) configurent la connexion à deux facteurs, pour que personne ne reste bloqué seul.',
   'mfa.without': 'Sans connexion à deux facteurs : {list}.',
   'mfa.cli_note': 'Bloqué ? Sur le serveur : pgkiln admin reset-2fa <developer> ou pgkiln admin set-2fa-policy off.',
+  // ------------------------------------------------------------ Security: passkeys and trusted browsers (sprint 127)
+  'mfa.kind': 'Type',
+  'mfa.kind_passkey': 'Clés d’accès',
+  'mfa.kind_app': 'Applications d’authentification',
+  'mfa.other_domain': 'pour {domain}',
+  'mfa.other_domain_help': 'Créée pour {domain} : elle ne fonctionne pas à cette adresse. Ajoutez ici une nouvelle clé.',
+  'mfa.passkey_intro': 'Connectez-vous avec votre empreinte, votre visage, le verrouillage d’écran ou une clé de sécurité. Une clé d’accès ne fonctionne que sur ce site.',
+  'mfa.passkey_default': 'Clé d’accès',
+  'mfa.add_passkey': 'Ajouter une clé d’accès',
+  'mfa.passkey_needs_js': 'Ajouter une clé d’accès nécessite JavaScript ; une application d’authentification fonctionne sans.',
+  'mfa.passkey_failed': 'La clé d’accès n’a pas fonctionné. Réessayez ou utilisez un code.',
+  'mfa.passkey_known': 'Cette clé d’accès est déjà ajoutée.',
+  'mfa.passkey_added': 'Clé d’accès ajoutée : vous pouvez désormais vous connecter avec elle.',
+  'mfa.remove_passkey': 'Supprimer cette clé d’accès',
+  'mfa.use_passkey': 'Utiliser une clé d’accès',
+  'mfa.trust_browser': 'Faire confiance à ce navigateur pendant {days} jours',
+  'mfa.trusted_title': 'Navigateurs de confiance',
+  'mfa.trusted_count': 'Navigateurs qui passent la seconde étape : {n} (jusqu’à {days} jours).',
+  'mfa.trusted_off': 'La confiance envers les navigateurs est désactivée.',
+  'mfa.forget_browsers': 'Oublier les navigateurs de confiance',
+  'mfa.browsers_forgotten': 'Chaque navigateur redemande la seconde étape.',
+  'mfa.trust_days': 'Faire confiance à un navigateur (jours)',
+  'mfa.trust_days_help': 'Après la seconde étape, un développeur peut la passer dans ce navigateur pendant ce nombre de jours. 0 : jamais.',
+  'mfa.passkey_needs_host': 'Les clés d’accès ont besoin d’un nom d’hôte, pas d’une adresse IP ({host}) : ouvrez le builder sur localhost ou son nom de domaine.',
+  'signin.passkey': 'Se connecter avec une clé d’accès',
+  'mfa.passkey_signin': 'Les développeurs peuvent se connecter avec une clé d’accès seule (sans mot de passe)',
+  'mfa.passkey_signin_help': 'Seulement quand l’appareil a vérifié le développeur (empreinte, visage ou code PIN) : la clé compte alors pour les deux facteurs.',
+  'mfa.weak_required': 'La connexion à deux facteurs est obligatoire : changez le mot de passe par défaut avant de continuer.',
+  'wsp.mfa': 'Connexion à deux facteurs',
+  'wsp.mfa_required': 'Exiger la connexion à deux facteurs des développeurs de cet espace de travail',
+  'wsp.mfa_required_help': 'En plus de la politique de l’instance. Les développeurs sans clé d’accès ni application d’authentification ont le délai de grâce de l’instance, puis seulement leur page Sécurité.',
+  'wsp.mfa_since': 'Obligatoire depuis le {date}.',
+  'wsp.mfa_without': 'Pas encore configuré : {list}.',
+  'wsp.mfa_save': 'Enregistrer la règle à deux facteurs',
+  'wsp.mfa_on': 'Les développeurs de cet espace de travail ont besoin de la connexion à deux facteurs.',
+  'wsp.mfa_off': 'L’espace de travail n’exige plus la connexion à deux facteurs (la politique de l’instance s’applique toujours).',
 };

package/src/builder/i18n/nl.ts

@@ -1714,16 +1714,16 @@ export const nl: BuilderMessages = {
   // ------------------------------------------------------------ Security: two-factor sign-in (sprint 126)
   'mfa.menu': 'Aanmelden in twee stappen',
   'mfa.title': 'Beveiliging',
-  'mfa.intro': 'Meld u na uw wachtwoord aan met een code uit een authenticator-app. Met herstelcodes komt u binnen als u de telefoon kwijtraakt.',
-  'mfa.required_you': 'Uw beheerder vereist aanmelden in twee stappen: voeg een authenticator-app toe.',
+  'mfa.intro': 'Bevestig na uw wachtwoord dat u het bent met een passkey (vingerafdruk, gezicht, beveiligingssleutel) of een code uit een authenticator-app. Met herstelcodes komt u binnen als u die kwijtraakt.',
+  'mfa.required_you': 'Uw beheerder vereist aanmelden in twee stappen: voeg een passkey of een authenticator-app toe.',
   'mfa.banner': 'Aanmelden in twee stappen is verplicht. Stel het in vóór {date}: {link}',
   'mfa.set_up_now': 'nu instellen',
-  'mfa.apps': 'Authenticator-apps',
+  'mfa.factors': 'Passkeys en authenticator-apps',
   'mfa.app_name': 'Naam',
   'mfa.app_default': 'Telefoon',
   'mfa.added': 'Toegevoegd',
   'mfa.last_used': 'Laatst gebruikt',
-  'mfa.no_apps': 'Nog geen authenticator-app: u meldt zich alleen met uw wachtwoord aan.',
+  'mfa.no_apps': 'Nog geen tweede factor: u meldt zich alleen met uw wachtwoord aan.',
   'mfa.add_app': 'Authenticator-app toevoegen',
   'mfa.no_key': 'Aanmelden in twee stappen heeft de instantiesleutel (PGKILN_SECRET_KEY) nodig om het geheim van de app op te slaan.',
   'mfa.scan': 'Scan de QR-code met een authenticator-app.',
@@ -1739,28 +1739,28 @@ export const nl: BuilderMessages = {
   'mfa.remove_app': 'Deze app verwijderen',
   'mfa.your_password': 'Uw wachtwoord',
   'mfa.wrong_password': 'Onjuist wachtwoord.',
-  'mfa.cannot_remove_required': 'Aanmelden in twee stappen is voor u verplicht: voeg eerst een andere app toe.',
+  'mfa.cannot_remove_required': 'Aanmelden in twee stappen is voor u verplicht: voeg eerst een andere passkey of app toe.',
   'mfa.cannot_remove_admin': 'Minstens twee beheerders (of alle, als het er minder zijn) moeten aanmelden in twee stappen houden zolang het beleid aan staat.',
   'mfa.keep_admins': 'Nu niet: het beleid vereist minstens twee beheerders met aanmelden in twee stappen (of alle, als het er minder zijn).',
-  'mfa.removed': 'Authenticator-app verwijderd.',
+  'mfa.removed': 'Verwijderd.',
   'mfa.codes_title': 'Herstelcodes',
   'mfa.codes_once': 'Bewaar deze codes op een veilige plek, niet bij uw telefoon. Elke code vervangt één keer een app-code. Ze worden alleen nu getoond.',
   'mfa.codes_saved': 'Ik heb deze codes bewaard',
   'mfa.codes_done': 'Klaar',
   'mfa.codes_kept': 'Herstelcodes bewaard.',
   'mfa.codes_left': 'Ongebruikte herstelcodes: {n}.',
-  'mfa.codes_after': 'U krijgt herstelcodes zodra u een authenticator-app toevoegt.',
+  'mfa.codes_after': 'U krijgt herstelcodes zodra u een passkey of authenticator-app toevoegt.',
   'mfa.codes_low': 'Nog maar weinig herstelcodes: maak nieuwe.',
   'mfa.codes_new': 'Nieuwe herstelcodes',
   'mfa.codes_new_confirm': 'Nieuwe herstelcodes maken? De oude werken dan niet meer.',
   'mfa.expired': 'Het aanmelden duurde te lang: meld u opnieuw aan.',
   'mfa.step_title': 'Aanmelden in twee stappen',
-  'mfa.step_intro': 'Voer de code uit uw authenticator-app voor {user} in.',
+  'mfa.step_intro': 'Bevestig dat u het bent, {user}: gebruik een passkey of voer een code uit uw authenticator-app in.',
   'mfa.code': 'Code',
   'mfa.code_help': '6 cijfers uit de app, of een van uw herstelcodes.',
   'mfa.verify': 'Controleren',
   'mfa.cancel': 'Terug naar aanmelden',
-  'mfa.locked_out': 'Telefoon en codes kwijt? Vraag een beheerder uw aanmelden in twee stappen te resetten.',
+  'mfa.locked_out': 'Telefoon, sleutel en codes kwijt? Vraag een beheerder uw aanmelden in twee stappen te resetten.',
   'mfa.wrong': 'Die code klopt niet of is al gebruikt.',
   'mfa.column': 'Twee stappen',
   'mfa.on': 'aan',
@@ -1784,4 +1784,40 @@ export const nl: BuilderMessages = {
   'mfa.policy_needs_admins': 'Eerst moeten minstens twee beheerders (of alle, als het er minder zijn) aanmelden in twee stappen instellen, zodat niemand alleen buitengesloten raakt.',
   'mfa.without': 'Zonder aanmelden in twee stappen: {list}.',
   'mfa.cli_note': 'Buitengesloten? Op de server: pgkiln admin reset-2fa <developer> of pgkiln admin set-2fa-policy off.',
+  // ------------------------------------------------------------ Security: passkeys and trusted browsers (sprint 127)
+  'mfa.kind': 'Soort',
+  'mfa.kind_passkey': 'Passkeys',
+  'mfa.kind_app': 'Authenticator-apps',
+  'mfa.other_domain': 'voor {domain}',
+  'mfa.other_domain_help': 'Gemaakt voor {domain}: werkt niet op dit adres. Voeg hier een nieuwe passkey toe.',
+  'mfa.passkey_intro': 'Meld u aan met uw vingerafdruk, gezicht, schermvergrendeling of een beveiligingssleutel. Een passkey werkt alleen op deze site.',
+  'mfa.passkey_default': 'Passkey',
+  'mfa.add_passkey': 'Passkey toevoegen',
+  'mfa.passkey_needs_js': 'Een passkey toevoegen vraagt JavaScript; een authenticator-app werkt zonder.',
+  'mfa.passkey_failed': 'De passkey werkte niet. Probeer het opnieuw of gebruik een code.',
+  'mfa.passkey_known': 'Deze passkey is al toegevoegd.',
+  'mfa.passkey_added': 'Passkey toegevoegd: voortaan kunt u zich ermee aanmelden.',
+  'mfa.remove_passkey': 'Deze passkey verwijderen',
+  'mfa.use_passkey': 'Passkey gebruiken',
+  'mfa.trust_browser': 'Deze browser {days} dagen vertrouwen',
+  'mfa.trusted_title': 'Vertrouwde browsers',
+  'mfa.trusted_count': 'Browsers die de tweede stap overslaan: {n} (hoogstens {days} dagen).',
+  'mfa.trusted_off': 'Browsers vertrouwen staat uit.',
+  'mfa.forget_browsers': 'Vertrouwde browsers vergeten',
+  'mfa.browsers_forgotten': 'Elke browser vraagt weer om de tweede stap.',
+  'mfa.trust_days': 'Browser vertrouwen (dagen)',
+  'mfa.trust_days_help': 'Na de tweede stap mag een ontwikkelaar die in die browser zoveel dagen overslaan. 0: nooit.',
+  'mfa.passkey_needs_host': 'Passkeys hebben een hostnaam nodig, geen IP-adres ({host}): open de builder via localhost of de domeinnaam.',
+  'signin.passkey': 'Aanmelden met een passkey',
+  'mfa.passkey_signin': 'Ontwikkelaars mogen alleen met een passkey aanmelden (zonder wachtwoord)',
+  'mfa.passkey_signin_help': 'Alleen als het apparaat de ontwikkelaar heeft gecontroleerd (vingerafdruk, gezicht of pincode): de passkey telt dan als beide factoren.',
+  'mfa.weak_required': 'Tweestapsaanmelding is verplicht: wijzig het standaardwachtwoord voordat u verdergaat.',
+  'wsp.mfa': 'Tweestapsaanmelding',
+  'wsp.mfa_required': 'Tweestapsaanmelding verplichten voor de ontwikkelaars van deze werkruimte',
+  'wsp.mfa_required_help': 'Bovenop het beleid van de instantie. Ontwikkelaars zonder passkey of authenticator-app krijgen de overgangstermijn van de instantie, daarna alleen hun beveiligingspagina.',
+  'wsp.mfa_since': 'Verplicht sinds {date}.',
+  'wsp.mfa_without': 'Nog niet ingesteld: {list}.',
+  'wsp.mfa_save': 'Tweestapsregel opslaan',
+  'wsp.mfa_on': 'De ontwikkelaars van deze werkruimte hebben tweestapsaanmelding nodig.',
+  'wsp.mfa_off': 'De werkruimte verplicht geen tweestapsaanmelding meer (het beleid van de instantie blijft gelden).',
 };

package/src/builder/i18n/pt.ts

@@ -1714,16 +1714,16 @@ export const pt: BuilderMessages = {
   // ------------------------------------------------------------ Security: two-factor sign-in (sprint 126)
   'mfa.menu': 'Login em duas etapas',
   'mfa.title': 'Segurança',
-  'mfa.intro': 'Entre com um código de um aplicativo autenticador depois da senha. Os códigos de recuperação permitem entrar se você perder o telefone.',
-  'mfa.required_you': 'Seu administrador exige login em duas etapas: adicione um aplicativo autenticador.',
+  'mfa.intro': 'Depois da senha, confirme que é você com uma chave de acesso (digital, rosto, chave de segurança) ou um código de um aplicativo autenticador. Os códigos de recuperação permitem entrar se você os perder.',
+  'mfa.required_you': 'Seu administrador exige login em duas etapas: adicione uma chave de acesso ou um aplicativo autenticador.',
   'mfa.banner': 'O login em duas etapas é obrigatório. Configure-o antes de {date}: {link}',
   'mfa.set_up_now': 'configurar agora',
-  'mfa.apps': 'Aplicativos autenticadores',
+  'mfa.factors': 'Chaves de acesso e aplicativos autenticadores',
   'mfa.app_name': 'Nome',
   'mfa.app_default': 'Telefone',
   'mfa.added': 'Adicionado',
   'mfa.last_used': 'Último uso',
-  'mfa.no_apps': 'Nenhum aplicativo autenticador ainda: você entra apenas com sua senha.',
+  'mfa.no_apps': 'Nenhum segundo fator ainda: você entra apenas com sua senha.',
   'mfa.add_app': 'Adicionar um aplicativo autenticador',
   'mfa.no_key': 'O login em duas etapas precisa da chave da instância (PGKILN_SECRET_KEY) para guardar o segredo do aplicativo.',
   'mfa.scan': 'Leia o código QR com um aplicativo autenticador.',
@@ -1739,28 +1739,28 @@ export const pt: BuilderMessages = {
   'mfa.remove_app': 'Remover este aplicativo',
   'mfa.your_password': 'Sua senha',
   'mfa.wrong_password': 'Senha incorreta.',
-  'mfa.cannot_remove_required': 'O login em duas etapas é obrigatório para você: adicione outro aplicativo antes de remover este.',
+  'mfa.cannot_remove_required': 'O login em duas etapas é obrigatório para você: adicione outra chave ou aplicativo antes de remover este.',
   'mfa.cannot_remove_admin': 'Pelo menos dois administradores (ou todos, se forem menos) devem manter o login em duas etapas enquanto a política estiver ativa.',
   'mfa.keep_admins': 'Agora não: a política exige pelo menos dois administradores com login em duas etapas (ou todos, se forem menos).',
-  'mfa.removed': 'Aplicativo autenticador removido.',
+  'mfa.removed': 'Removido.',
   'mfa.codes_title': 'Códigos de recuperação',
   'mfa.codes_once': 'Guarde estes códigos em local seguro, longe do telefone. Cada um substitui uma vez um código do aplicativo. Eles são mostrados só agora.',
   'mfa.codes_saved': 'Guardei estes códigos',
   'mfa.codes_done': 'Concluído',
   'mfa.codes_kept': 'Códigos de recuperação guardados.',
   'mfa.codes_left': 'Códigos de recuperação não usados: {n}.',
-  'mfa.codes_after': 'Você recebe códigos de recuperação ao adicionar um aplicativo autenticador.',
+  'mfa.codes_after': 'Você recebe códigos de recuperação ao adicionar uma chave de acesso ou um aplicativo autenticador.',
   'mfa.codes_low': 'Restam poucos códigos de recuperação: gere novos.',
   'mfa.codes_new': 'Novos códigos de recuperação',
   'mfa.codes_new_confirm': 'Gerar novos códigos de recuperação? Os antigos deixam de funcionar.',
   'mfa.expired': 'O login demorou demais: entre novamente.',
   'mfa.step_title': 'Login em duas etapas',
-  'mfa.step_intro': 'Digite o código do seu aplicativo autenticador para {user}.',
+  'mfa.step_intro': 'Confirme que é você, {user}: use uma chave de acesso ou digite um código do seu aplicativo autenticador.',
   'mfa.code': 'Código',
   'mfa.code_help': '6 dígitos do aplicativo ou um dos seus códigos de recuperação.',
   'mfa.verify': 'Verificar',
   'mfa.cancel': 'Voltar ao login',
-  'mfa.locked_out': 'Perdeu o telefone e os códigos? Peça a um administrador para redefinir seu login em duas etapas.',
+  'mfa.locked_out': 'Perdeu o telefone, a chave e os códigos? Peça a um administrador para redefinir seu login em duas etapas.',
   'mfa.wrong': 'Esse código não está certo ou já foi usado.',
   'mfa.column': 'Duas etapas',
   'mfa.on': 'ativado',
@@ -1784,4 +1784,40 @@ export const pt: BuilderMessages = {
   'mfa.policy_needs_admins': 'Primeiro, pelo menos dois administradores (ou todos, se forem menos) configuram o login em duas etapas, para ninguém ficar bloqueado sozinho.',
   'mfa.without': 'Sem login em duas etapas: {list}.',
   'mfa.cli_note': 'Bloqueado? No servidor: pgkiln admin reset-2fa <developer> ou pgkiln admin set-2fa-policy off.',
+  // ------------------------------------------------------------ Security: passkeys and trusted browsers (sprint 127)
+  'mfa.kind': 'Tipo',
+  'mfa.kind_passkey': 'Chaves de acesso',
+  'mfa.kind_app': 'Aplicativos autenticadores',
+  'mfa.other_domain': 'para {domain}',
+  'mfa.other_domain_help': 'Criada para {domain}: não funciona neste endereço. Adicione aqui uma nova chave.',
+  'mfa.passkey_intro': 'Entre com sua digital, rosto, bloqueio de tela ou uma chave de segurança. Uma chave de acesso só funciona neste site.',
+  'mfa.passkey_default': 'Chave de acesso',
+  'mfa.add_passkey': 'Adicionar uma chave de acesso',
+  'mfa.passkey_needs_js': 'Adicionar uma chave de acesso exige JavaScript; um aplicativo autenticador funciona sem ele.',
+  'mfa.passkey_failed': 'A chave de acesso não funcionou. Tente de novo ou use um código.',
+  'mfa.passkey_known': 'Esta chave de acesso já foi adicionada.',
+  'mfa.passkey_added': 'Chave de acesso adicionada: a partir de agora você pode entrar com ela.',
+  'mfa.remove_passkey': 'Remover esta chave de acesso',
+  'mfa.use_passkey': 'Usar uma chave de acesso',
+  'mfa.trust_browser': 'Confiar neste navegador por {days} dias',
+  'mfa.trusted_title': 'Navegadores confiáveis',
+  'mfa.trusted_count': 'Navegadores que pulam a segunda etapa: {n} (até {days} dias).',
+  'mfa.trusted_off': 'A confiança em navegadores está desativada.',
+  'mfa.forget_browsers': 'Esquecer os navegadores confiáveis',
+  'mfa.browsers_forgotten': 'Todos os navegadores voltam a pedir a segunda etapa.',
+  'mfa.trust_days': 'Confiar em um navegador (dias)',
+  'mfa.trust_days_help': 'Depois da segunda etapa, um desenvolvedor pode pulá-la naquele navegador por estes dias. 0: nunca.',
+  'mfa.passkey_needs_host': 'Chaves de acesso precisam de um nome de host, não de um endereço IP ({host}): abra o construtor em localhost ou no nome de domínio.',
+  'signin.passkey': 'Entrar com uma chave de acesso',
+  'mfa.passkey_signin': 'Os desenvolvedores podem entrar só com uma chave de acesso (sem senha)',
+  'mfa.passkey_signin_help': 'Só quando o dispositivo verificou o desenvolvedor (impressão digital, rosto ou PIN): a chave conta então como os dois fatores.',
+  'mfa.weak_required': 'O login em duas etapas é obrigatório: altere a senha padrão antes de continuar.',
+  'wsp.mfa': 'Login em duas etapas',
+  'wsp.mfa_required': 'Exigir login em duas etapas dos desenvolvedores deste espaço de trabalho',
+  'wsp.mfa_required_help': 'Além da política da instância. Desenvolvedores sem chave de acesso ou app autenticador têm o período de carência da instância e depois só a página de segurança.',
+  'wsp.mfa_since': 'Obrigatório desde {date}.',
+  'wsp.mfa_without': 'Ainda não configurado: {list}.',
+  'wsp.mfa_save': 'Salvar a regra de duas etapas',
+  'wsp.mfa_on': 'Os desenvolvedores deste espaço de trabalho precisam do login em duas etapas.',
+  'wsp.mfa_off': 'O espaço de trabalho já não exige login em duas etapas (a política da instância continua valendo).',
 };

package/src/builder/routes.ts

@@ -27,7 +27,10 @@ import { appFromFileRoutes } from './appfromfile.ts';
 import { clearDevbar } from '../runtime/devbar.ts';
 import { EMAIL } from './find-workspace.ts';
 import { cookieLanguage, LANG_COOKIE, tr, translatorFor, validBuilderLanguage } from './i18n.ts';
-import { checkSecondFactor, codesLeft, hasFactor, leavesTooFewAdmins } from '../mfa.ts';
+import { checkSecondFactor, codesLeft, forgetBrowsers, hasFactor, isTrustedBrowser, leavesTooFewAdmins, passkeyByCredential, passkeySignin, passkeysOf, trustBrowser, trustDays, usePasskey, userHandle } from '../mfa.ts';
+import { isIP } from 'node:net';
+import { giveChallenge, takeChallenge } from './security.ts';
+import { relyingParty, verifyAssertion, WebAuthnError } from '../webauthn.ts';
 import { chooseLanguage, langCookieOptions, languageRoutes, signInLanguageLinks } from './language.ts';
 
 // Builder pages: sign-in, workspace and app home, settings, activity and
@@ -65,6 +68,8 @@ export async function builderRoutes(app: FastifyInstance) {
     await saveState(s);
     const r = remembered(req);
     const next = safeNext(req.query?.next);
+    // (sprint 128) a passkey alone, when the instance allows it and the address is a host name
+    const alone = (await passkeySignin()) && !isIP(relyingParty(req).rpId);
     const field = (name: string, label: string, ic: string, value: string, opts: { type?: string; required?: boolean; auto?: string; placeholder?: string; reveal?: boolean }) =>
       html`<div class="field signin-field"><label class="sr-only" for="f_${name}">${label}</label>
         <div class="signin-input">${icon(ic)}<input id="f_${name}" name="${name}" type="${opts.type ?? 'text'}" value="${value}" placeholder="${opts.placeholder ?? label}"${opts.required ? raw(' required') : ''}${opts.auto ? raw(` autocomplete="${opts.auto}"`) : ''}>
@@ -90,6 +95,9 @@ export async function builderRoutes(app: FastifyInstance) {
               ${field('password', tx('signin.password'), 'key', '', { type: 'password', required: true, auto: 'current-password', reveal: true })}
               <label class="check signin-remember"><input type="checkbox" name="remember" value="1"${r ? raw(' checked') : ''}> ${tx('signin.remember')}</label>
               <button class="btn btn-hot signin-submit">${tx('signin.submit')}</button>
+              ${alone ? html`<input type="hidden" name="credentialId"><input type="hidden" name="clientDataJSON"><input type="hidden" name="authenticatorData"><input type="hidden" name="signature"><input type="hidden" name="userHandle">
+                <button class="btn signin-submit signin-passkey" hidden data-passkey="${BASE}/login/passkey/options" data-passkey-submit="${BASE}/login/passkey" data-passkey-error="${tx('mfa.passkey_failed')}">${icon('fingerprint')} ${tx('signin.passkey')}</button>
+                <p class="small" role="status" data-passkey-status></p>` : ''}
               <p class="muted small signin-hint">${tx('signin.hint')}</p>
               <nav class="signin-actions" aria-label="${tx('signin.quick')}">
                 <a href="${BASE}/find-workspace">${icon('search')} ${tx('signin.find_ws')}</a>
@@ -136,22 +144,15 @@ export async function builderRoutes(app: FastifyInstance) {
       [username, password],
     );
     // a workspace, when given, must be one of the developer's (administrators: any); the same answer otherwise
-    const ws = dev && workspace
-      ? await owner.one<{ id: number }>(
-          `select w.id from meta.workspace w
-            where lower(w.name) = lower($1)
-              and (exists (select 1 from meta.developer d where d.username = $2 and d.is_admin)
-                   or exists (select 1 from meta.workspace_member m where m.workspace_id = w.id and m.username = $2))`,
-          [workspace, dev.username],
-        )
-      : undefined;
+    const ws = dev && workspace ? await workspaceOf(workspace, dev.username) : undefined;
     if (!dev || (workspace && !ws)) {
       await logActivity({ username: username.slice(0, 100), event: 'login_failed', ip, detail: workspace ? 'builder (workspace)' : 'builder' });
       flash(s, tx(workspace ? 'signin.invalid_ws' : 'signin.invalid'), 'error');
       return back(reply, s, again);
     }
-    // (sprint 126, SEC-2) a developer with a second factor: the password was right, the session comes after the code
-    if (await hasFactor(dev.username)) {
+    // (sprint 126, SEC-2) a developer with a second factor: the password was right, the session comes after the code;
+    // (sprint 127) unless this browser was trusted after a second factor, for the instance's number of days
+    if ((await hasFactor(dev.username)) && !(await isTrustedBrowser(dev.username, req.cookies?.[TRUST_COOKIE]))) {
       s.state.__MFA = JSON.stringify({ u: dev.username, ws: ws ? String(ws.id) : null, w: workspace, next, remember: req.body?.remember === '1', weak: password === 'admin' || password === dev.username, at: Date.now() });
       await saveState(s);
       return reply.redirect(`${BASE}/login/2fa`, 303);
@@ -159,6 +160,75 @@ export async function builderRoutes(app: FastifyInstance) {
     return finishSignIn(req, reply, s, { username: dev.username, language: dev.language }, { ws: ws ? String(ws.id) : null, workspace, next, remember: req.body?.remember === '1', weak: password === 'admin' || password === dev.username, picked, detail: 'builder' });
   });
 
+  /** A workspace by name, when it is one of the developer's (administrators: any). */
+  const workspaceOf = (workspace: string, username: string) =>
+    owner.one<{ id: number }>(
+      `select w.id from meta.workspace w
+        where lower(w.name) = lower($1)
+          and (exists (select 1 from meta.developer d where d.username = $2 and d.is_admin)
+               or exists (select 1 from meta.workspace_member m where m.workspace_id = w.id and m.username = $2))`,
+      [workspace, username],
+    );
+
+  // (sprint 128, SEC-2) signing in with a passkey alone: no user name, no password. The browser offers the
+  // passkeys it holds for this site (discoverable credentials); the authenticator must verify the developer
+  // (fingerprint, face, PIN), so the passkey counts as both factors. Failures count with wrong passwords.
+  app.post(`${BASE}/login/passkey/options`, async (req: Req, reply) => {
+    const s = await getSession(req, reply, null, BASE);
+    if (req.body?.__csrf !== s.csrf_token) return reply.code(403).send('Reload the page.');
+    if (!(await passkeySignin())) return reply.code(404).send('Passkey sign-in is off.');
+    const challenge = giveChallenge(s as Parameters<typeof giveChallenge>[0], 'get');
+    await saveState(s);
+    reply.header('cache-control', 'no-store');
+    return reply.send({ mode: 'get', challenge, rpId: relyingParty(req).rpId, allow: [], uv: 'required' });
+  });
+  app.post(`${BASE}/login/passkey`, async (req: Req, reply) => {
+    const s = await getSession(req, reply, null, BASE);
+    const ip = clientIp(req);
+    const picked = validBuilderLanguage(s.state.__BLANG);
+    const tx = translatorFor(picked ?? cookieLanguage(req));
+    const workspace = String(req.body?.workspace ?? '').trim().slice(0, 60);
+    const next = safeNext(req.body?.next);
+    const again = next === `${BASE}/home` ? `${BASE}/login` : `${BASE}/login?next=${encodeURIComponent(next)}`;
+    const challenge = takeChallenge(s as Parameters<typeof takeChallenge>[0], 'get');
+    if (req.body?.__csrf !== s.csrf_token || !(await passkeySignin())) {
+      flash(s, tx('signin.expired'), 'error');
+      return back(reply, s, again);
+    }
+    const rp = relyingParty(req);
+    const key = await passkeyByCredential(String(req.body?.credentialId ?? ''), rp.rpId);
+    const who = key?.username ?? '';
+    if (await loginThrottled(null, who, ip)) {
+      logActivity({ username: who, event: 'login_locked', ip, detail: 'builder passkey' });
+      flash(s, tx('signin.throttled'), 'error');
+      return back(reply, s, again);
+    }
+    let why = key ? '' : 'unknown passkey';
+    if (key && !challenge) why = 'no or an expired challenge';
+    else if (key && req.body?.userHandle && req.body.userHandle !== userHandle(key.username)) why = 'the user handle does not match';
+    else if (key && challenge) {
+      try {
+        const r = verifyAssertion(
+          { clientDataJSON: String(req.body?.clientDataJSON ?? ''), authenticatorData: String(req.body?.authenticatorData ?? ''), signature: String(req.body?.signature ?? '') },
+          { alg: key.alg, jwk: key.public_key, signCount: Number(key.sign_count) }, { challenge, ...rp });
+        if (!r.userVerified) why = 'the authenticator did not verify the user';
+        else if (!(await usePasskey(key.id, key.sign_count, r.signCount))) why = 'used at the same time elsewhere';
+      } catch (e) {
+        why = e instanceof WebAuthnError ? e.message : 'unreadable answer';
+      }
+    }
+    const ws = !why && workspace ? await workspaceOf(workspace, who) : undefined;
+    if (!why && workspace && !ws) why = 'not a workspace of the developer';
+    if (why) {
+      await logActivity({ username: who.slice(0, 100), event: 'login_failed', ip, detail: `builder passkey: ${why}` });
+      flash(s, tx(why === 'not a workspace of the developer' ? 'signin.invalid_ws' : 'mfa.passkey_failed'), 'error');
+      return back(reply, s, again);
+    }
+    const dev = await owner.one<{ username: string; language: string | null }>('select username, language from meta.developer where username = $1', [who]);
+    if (!dev) return back(reply, s, again);
+    return finishSignIn(req, reply, s, dev, { ws: ws ? String(ws.id) : null, workspace, next, remember: req.body?.remember === '1', weak: false, picked, detail: 'builder passkey' });
+  });
+
   /** The session after a successful sign-in (password, and the second factor when the developer has one). */
   async function finishSignIn(req: Req, reply: Parameters<typeof back>[0], s: Awaited<ReturnType<typeof getSession>>, dev: { username: string; language: string | null },
     o: { ws: string | null; workspace: string; next: string; remember: boolean; weak: boolean; picked: ReturnType<typeof validBuilderLanguage>; detail: string }) {
@@ -187,8 +257,17 @@ export async function builderRoutes(app: FastifyInstance) {
     return reply.redirect(next, 303);
   }
 
-  // (sprint 126, SEC-2) the second step: a code from the authenticator app, or a recovery code
+  // (sprint 126, SEC-2) the second step: a code from the authenticator app, or a recovery code;
+  // (sprint 127) or a passkey, and "trust this browser" when the instance allows it
   const MFA_SECONDS = 300;
+  const TRUST_COOKIE = 'pgkiln_btrust';
+  const trustThisBrowser = async (req: Req, reply: Parameters<typeof back>[0], username: string) => {
+    const days = await trustDays();
+    if (!days || req.body?.trust !== '1') return;
+    const token = await trustBrowser(username, days, String(req.headers['user-agent'] ?? ''));
+    reply.setCookie(TRUST_COOKIE, token, { path: BASE, httpOnly: true, sameSite: 'lax', maxAge: days * 86400, secure: process.env.COOKIE_SECURE === 'true' });
+    logActivity({ username, event: '2fa_trusted_browser', ip: clientIp(req), detail: `${days} days` });
+  };
   const pendingMfa = (s: { state: Record<string, any> }) => {
     try {
       const p = JSON.parse(String(s.state.__MFA ?? ''));
@@ -209,6 +288,7 @@ export async function builderRoutes(app: FastifyInstance) {
     }
     const error = takeFlash(s, '__ERROR');
     await saveState(s);
+    const [keys, days] = await Promise.all([passkeysOf(p.u, relyingParty(req).rpId), trustDays()]);
     return reply.type('text/html').send(documentShell(
       `${tx('mfa.step_title')} · ${tx('shell.builder')}`,
       html`<main class="signin">
@@ -223,10 +303,14 @@ export async function builderRoutes(app: FastifyInstance) {
             <p class="muted u-mt0">${tx('mfa.step_intro', { user: p.u })}</p>
             ${error ? html`<div class="alert alert-error" role="alert">${error}</div>` : ''}
             ${csrf(s)}
+            ${keys.length ? html`<input type="hidden" name="credentialId"><input type="hidden" name="clientDataJSON"><input type="hidden" name="authenticatorData"><input type="hidden" name="signature">
+              <button class="btn btn-hot signin-submit" hidden data-passkey="${BASE}/login/2fa/passkey/options" data-passkey-submit="${BASE}/login/2fa/passkey" data-passkey-error="${tx('mfa.passkey_failed')}">${icon('fingerprint')} ${tx('mfa.use_passkey')}</button>
+              <p class="small" role="status" data-passkey-status></p>` : ''}
             <div class="field signin-field"><label class="label" for="f_code">${tx('mfa.code')}</label>
               <div class="signin-input">${icon('key')}<input id="f_code" name="code" required autocomplete="one-time-code" autofocus maxlength="20" spellcheck="false" autocapitalize="off"></div>
               <small class="help">${tx('mfa.code_help')}</small></div>
-            <button class="btn btn-hot signin-submit">${tx('mfa.verify')}</button>
+            ${days ? html`<label class="check"><input type="checkbox" name="trust" value="1"> ${tx('mfa.trust_browser', { days })}</label>` : ''}
+            <button class="btn${keys.length ? '' : ' btn-hot'} signin-submit">${tx('mfa.verify')}</button>
             <p class="muted small signin-hint"><a href="${BASE}/login">${tx('mfa.cancel')}</a> · ${tx('mfa.locked_out')}</p>
           </form>
         </section>
@@ -265,11 +349,69 @@ export async function builderRoutes(app: FastifyInstance) {
       const left = await codesLeft(p.u);
       await logActivity({ username: p.u, event: '2fa_recovery_used', ip, detail: `${left} left` });
       // to the Security page: one code fewer, maybe time for new ones
+      await trustThisBrowser(req, reply, p.u);
       return finishSignIn(req, reply, s, dev, { ws: p.ws, workspace: p.w, next: `${BASE}/security`, remember: p.remember, weak: p.weak, picked, detail: 'builder 2fa (recovery code)' });
     }
+    await trustThisBrowser(req, reply, p.u);
     return finishSignIn(req, reply, s, dev, { ws: p.ws, workspace: p.w, next: p.next, remember: p.remember, weak: p.weak, picked, detail: 'builder 2fa' });
   });
 
+  // (sprint 127) the second step with a passkey: options for navigator.credentials.get(), then the browser's answer
+  app.post(`${BASE}/login/2fa/passkey/options`, async (req: Req, reply) => {
+    const s = await getSession(req, reply, null, BASE);
+    const p = pendingMfa(s);
+    if (req.body?.__csrf !== s.csrf_token || !p) return reply.code(403).send('Sign in again.');
+    const rp = relyingParty(req);
+    const keys = await passkeysOf(p.u, rp.rpId);
+    if (!keys.length) return reply.code(404).send('No passkey for this site.');
+    const challenge = giveChallenge(s as Parameters<typeof giveChallenge>[0], 'get');
+    await saveState(s);
+    reply.header('cache-control', 'no-store');
+    return reply.send({ mode: 'get', challenge, rpId: rp.rpId, allow: keys.map((k) => ({ id: k.credential_id, transports: k.transports })) });
+  });
+  app.post(`${BASE}/login/2fa/passkey`, async (req: Req, reply) => {
+    const s = await getSession(req, reply, null, BASE);
+    const ip = clientIp(req);
+    const picked = validBuilderLanguage(s.state.__BLANG);
+    const tx = translatorFor(picked ?? cookieLanguage(req));
+    const p = pendingMfa(s);
+    const challenge = takeChallenge(s as Parameters<typeof takeChallenge>[0], 'get');
+    if (req.body?.__csrf !== s.csrf_token || !p) {
+      delete s.state.__MFA;
+      flash(s, tx(p ? 'signin.expired' : 'mfa.expired'), 'error');
+      return back(reply, s, `${BASE}/login`);
+    }
+    if (await loginThrottled(null, p.u, ip)) {
+      logActivity({ username: p.u, event: 'login_locked', ip, detail: 'builder 2fa' });
+      delete s.state.__MFA;
+      flash(s, tx('signin.throttled'), 'error');
+      return back(reply, s, `${BASE}/login`);
+    }
+    const rp = relyingParty(req);
+    const key = (await passkeysOf(p.u, rp.rpId)).find((k) => k.credential_id === String(req.body?.credentialId ?? ''));
+    let why = 'unknown passkey';
+    if (key && challenge) {
+      try {
+        const r = verifyAssertion(
+          { clientDataJSON: String(req.body?.clientDataJSON ?? ''), authenticatorData: String(req.body?.authenticatorData ?? ''), signature: String(req.body?.signature ?? '') },
+          { alg: key.alg, jwk: key.public_key, signCount: Number(key.sign_count) }, { challenge, ...rp });
+        if (await usePasskey(key.id, key.sign_count, r.signCount)) why = '';
+        else why = 'used at the same time elsewhere';
+      } catch (e) {
+        why = e instanceof WebAuthnError ? e.message : 'unreadable answer';
+      }
+    } else if (!challenge) why = 'no or an expired challenge';
+    if (why) {
+      await logActivity({ username: p.u, event: 'login_failed', ip, detail: `builder 2fa passkey: ${why}` });
+      flash(s, tx('mfa.passkey_failed'), 'error');
+      return back(reply, s, `${BASE}/login/2fa`);
+    }
+    const dev = await owner.one<{ username: string; language: string | null }>('select username, language from meta.developer where username = $1', [p.u]);
+    if (!dev) return back(reply, s, `${BASE}/login`);
+    await trustThisBrowser(req, reply, p.u);
+    return finishSignIn(req, reply, s, dev, { ws: p.ws, workspace: p.w, next: p.next, remember: p.remember, weak: p.weak, picked, detail: 'builder 2fa (passkey)' });
+  });
+
   app.post(`${BASE}/logout`, async (req: Req, reply) => {
     const s = await getSession(req, reply, null, BASE);
     if (req.body?.__csrf === s.csrf_token) {
@@ -865,8 +1007,9 @@ export async function builderRoutes(app: FastifyInstance) {
         [s.username, req.body?.current ?? '', req.body?.password],
       );
       if (r.rowCount !== 1) throw new Error(tr(s)('dev.err.current'));
-      // End all other builder sessions of this developer.
+      // End all other builder sessions of this developer, and (sprint 127) forget the browsers they trusted.
       await owner.query('delete from meta.session where app_id is null and username = $1 and id <> $2', [s.username, s.id]);
+      await forgetBrowsers(s.username!);
       delete s.state.__WEAK;
       flash(s, tr(s)('dev.pw_changed'));
     } catch (e) {