@vonall/auth 0.2.1 → 0.3.0

package/dist/messages.js

@@ -43,6 +43,214 @@ export const en = {
     einladungHello: "Hello,",
     einladungBody: (inviter, app) => `${inviter || "Someone"} invites you to ${app}.`,
     einladungValid: (validUntil) => `The link works once and is valid until ${validUntil}.`,
+    // The login page
+    welcomeBack: "Welcome back",
+    logInTo: (app) => `Log in to ${app}`,
+    forgotPassword: "Forgot your password?",
+    forgotIntro: "Enter your email address and we'll send you a link to reset it.",
+    email: "Email",
+    emailPlaceholder: "you@example.org",
+    password: "Password",
+    sendTheLink: "Send the link",
+    backToLogin: "Back to login",
+    orWithEmail: "or with email",
+    logIn: "Log in",
+    noAccountYet: "No account yet?",
+    signUp: "Sign up",
+    continueWith: (provider) => `Continue with ${provider}`,
+    accountNotLinked: "This Google or GitHub account doesn't confirm your email address. Log in with email and password and link it in the settings.",
+    noNewAccountInvite: "New accounts need an invitation. Ask someone who already has an account for an invitation link.",
+    noNewAccountOpen: "Accounts can't be created at the moment. Please try again later.",
+    loginTooOld: "Your login is more than a day old. Please log in again for this action.",
+    confirmEmailFirst: "Confirm your email address first: we just sent you a new link.",
+    resetLinkNotSent: "The reset link could not be sent.",
+    resetLinkSent: "If an account with this email address exists, a link to reset the password has been sent.",
+    resetLinkNotRequested: "The reset link could not be requested.",
+    invalidEmailDot: "Please enter a valid email address.",
+    // Two-factor on login
+    twoFactorTitle: "Two-factor authentication",
+    twoFactorEnterCode: "Enter the 6-digit code from your authenticator app.",
+    confirm: "Confirm",
+    cancel: "Cancel",
+    invalidCode: "Please enter a valid 6-digit code.",
+    wrongCode: "Wrong or expired code.",
+    codeNotVerified: "The code could not be verified.",
+    // Signup
+    createAccount: "Create an account",
+    invitesYouTo: (inviter, app) => `${inviter} invites you to ${app}.`,
+    signUpWith: (providers) => `Sign up with ${providers} or with email and password`,
+    or: "or",
+    almostDone: (email, app) => `Almost done: if ${email} can be used for ${app}, a link to confirm it is on its way. Open it to start using ${app}.`,
+    accountReady: "Your account is ready.",
+    inviteOnly: (app) => `${app} is invite only. Ask someone who already has an account for an invitation link and open it on this device.`,
+    alreadyHaveAccount: "Already have an account?",
+    repeatPassword: "Repeat the password",
+    passwordsDontMatchDot: "The passwords don't match.",
+    needsValidEinladung: "Signing up needs a valid invitation.",
+    emailInUse: "This email address is already in use.",
+    signupFailed: "Signing up failed.",
+    // Reset
+    resetTitle: "Reset your password",
+    resetIntro: "Enter your new password",
+    resetNoToken: "No valid token found. Please request a new link to reset your password.",
+    resetLinkInvalid: "The reset link is invalid or incomplete.",
+    passwordTooShortDot: (min) => `The password needs at least ${min} characters.`,
+    newPassword: "New password",
+    confirmNewPassword: "Confirm the new password",
+    savePassword: "Save the password",
+    passwordNotReset: "The password could not be reset.",
+    passwordWasReset: "Password reset. You can log in now.",
+    somethingWentWrong: "Something went wrong.",
+    // The Einladung page
+    invitationTitle: "Invitation",
+    invitationTo: (app) => `Invitation to ${app}`,
+    invitesYou: (inviter) => `${inviter} invites you.`,
+    askForNewLink: "Please ask for a new link.",
+    toStartPage: "To the start page",
+    alreadyHaveAccountNoInvite: "You already have an account; you don't need this invitation.",
+    openApp: (app) => `Open ${app}`,
+    iHaveAnAccount: "I already have an account",
+    // Settings
+    settingsTitle: "Settings",
+    backToOverview: "Back to the overview",
+    user: "User",
+    profile: "Profile",
+    memberSince: (since) => `Member since ${since}`,
+    tabProfile: "Profile",
+    tabProfileHint: "Name and email",
+    tabSecurity: "Security",
+    tabSecurityHint: "Password and two-factor authentication",
+    tabSessions: "Sessions",
+    tabSessionsHint: "Devices you are logged in on",
+    tabLinks: "Linked accounts",
+    tabLinksHint: "GitHub and Google login",
+    tabInvitations: "Invitations",
+    tabInvitationsHint: "Invite someone",
+    tabDeletion: "Delete account",
+    tabDeletionHint: "Delete your account for good",
+    name: "Name",
+    yourName: "Your name",
+    save: "Save",
+    saving: "Saving…",
+    profileUpdated: "Profile updated",
+    profileNotUpdated: "The profile could not be updated",
+    loadingSecurity: "Loading security settings…",
+    changePassword: "Change password",
+    changing: "Changing…",
+    passwordChanged: "Password changed",
+    passwordNotChanged: "The password could not be changed",
+    currentPassword: "Current password",
+    confirmNewPasswordShort: "Confirm new password",
+    setPassword: "Set a password",
+    setPasswordIntro: "Your account has no password yet. Set one to log in with your email address and password as well, and to use two-factor authentication.",
+    setPasswordButton: "Set password",
+    passwordSet: "Password set",
+    passwordNotSet: "The password could not be set",
+    // Two-factor settings
+    twoFactorHeading: "Two-factor authentication (2FA)",
+    twoFactorIntro: "Protect your account with a one-time code from an authenticator app.",
+    on: "On",
+    off: "Off",
+    twoFactorProtects: "Two-factor authentication protects your account. To turn it off, enter your password.",
+    yourPassword: "Your password",
+    turningOff: "Turning off…",
+    turnOff: "Turn off",
+    turnOff2fa: "Turn off 2FA",
+    scanQr: "Scan the QR code",
+    qrAlt: "TOTP QR Code",
+    scanWithApp: "Scan this code with your authenticator app (e.g. Google Authenticator, Authy, Bitwarden).",
+    saveBackupCodes: "1. Save the backup codes",
+    backupCodesIntro: "Keep these one-time codes somewhere safe. Each lets you log in once if you lose access to your phone.",
+    copyBackupCodes: "Copy the backup codes",
+    backupCodesCopied: "Backup codes copied",
+    confirmSetup: "2. Confirm the setup",
+    enterCodeFromApp: "Enter the 6-digit code from the app",
+    checking: "Checking…",
+    turnOn2fa: "Turn on 2FA",
+    setup2faIntro: "To set up 2FA, confirm it is you by entering your password.",
+    starting: "Starting…",
+    start2faSetup: "Start 2FA setup",
+    enterPasswordOn: "Please enter your password to turn on 2FA.",
+    enterPasswordOff: "Please enter your password to turn off 2FA.",
+    twoFactorNotOn: "2FA could not be turned on",
+    twoFactorNotOff: "2FA could not be turned off",
+    twoFactorIsOn: "Two-factor authentication is on.",
+    twoFactorIsOff: "2FA is off.",
+    setupNotStarted: "The 2FA setup could not be started",
+    // Sessions
+    activeSessions: "Active sessions",
+    devicesLoggedIn: "The devices you are logged in on.",
+    endAllOthers: "End all others",
+    noActiveSessions: "No active sessions.",
+    unknownBrowser: "Unknown browser",
+    thisSession: "This session",
+    noIpAddress: "No IP address",
+    lastActive: (when) => `Last active: ${when}`,
+    unknown: "Unknown",
+    sessionEnded: "Session ended",
+    sessionNotEnded: "The session could not be ended",
+    otherSessionsEnded: "Other sessions ended",
+    otherSessionsNotEnded: "The other sessions could not be ended",
+    // Linked accounts
+    linkedAccounts: "Linked accounts",
+    linkedIntro: "Log in to your account with GitHub or Google as well.",
+    linked: "Linked",
+    notLinked: "Not linked",
+    unlink: "Unlink",
+    link: "Link",
+    noSocialLogin: "No GitHub or Google login is set up on this server.",
+    autoLinkNote: "If you log in with GitHub or Google and the provider confirms the same email as your account, the two are linked automatically.",
+    providerLinked: (provider) => `${provider} linked`,
+    providerUnlinked: (provider) => `${provider} unlinked`,
+    providerNotLinked: (provider) => `${provider} could not be linked`,
+    providerNotUnlinked: (provider) => `${provider} could not be unlinked`,
+    // Invitations
+    inviteSomeone: "Invite someone",
+    inviteIntro: "An invitation link works once and for 14 days. Whoever opens it can create an account.",
+    linkWord: "Link",
+    validUntil: (date) => `valid until ${date}`,
+    withdrawInvitation: "Withdraw invitation",
+    invitationWithdrawn: "Invitation withdrawn",
+    invitationNotWithdrawn: "The invitation could not be withdrawn.",
+    emailOptional: "Email (optional, otherwise just a link)",
+    creating: "Creating…",
+    createInvitation: "Create invitation",
+    copy: "Copy",
+    share: "Share",
+    linkShownOnce: "The link is shown only now. Send it by message or email.",
+    invitationText: (app, link) => `I'm inviting you to ${app}: ${link}`,
+    shareYourself: (error) => `${error}. Share the link yourself instead.`,
+    invitationSentTo: (email) => `Invitation sent to ${email}`,
+    invitationNotCreated: "The invitation could not be created.",
+    linkCopied: "Link copied",
+    copyLinkFailed: "Copying failed; select the link and copy it by hand.",
+    // Deletion
+    deleteForGood: "Delete your account for good",
+    cannotBeUndone: "This cannot be undone",
+    deletionText: "Your account is deleted with everything that belongs to it, your invitations and sessions included.",
+    deletionAgents: "Connected AI assistants lose their access.",
+    deletionNoLogin: "You won't be able to log in afterwards.",
+    typeToContinue: "to continue:",
+    type: "Type",
+    deleteWord: "DELETE",
+    deleting: "Deleting…",
+    deletePermanently: "Delete account permanently",
+    accountDeleted: "Your account has been deleted.",
+    accountNotDeleted: "The account could not be deleted.",
+    // Admin
+    administration: "Administration",
+    accounts: "Accounts",
+    since: (date) => `since ${date}`,
+    you: "(you)",
+    roleOf: (name) => `Role of ${name}`,
+    roleChanged: "Role changed",
+    deleteAccountOf: (name) => `Delete ${name}'s account`,
+    confirmDeleteAccount: (name) => `Delete ${name}'s account with all its data? This cannot be undone.`,
+    accountDeletedAdmin: "Account deleted",
+    invitations: "Invitations",
+    noOpenInvitations: "No open invitations.",
+    by: (inviter) => `by ${inviter}`,
+    didntWork: "That didn't work.",
 };
 export const de = {
     needsEinladung: "Zum Registrieren braucht es eine Einladung",
@@ -79,6 +287,202 @@ export const de = {
     einladungHello: "Hallo",
     einladungBody: (inviter, app) => `${inviter || "Jemand"} lädt dich zu ${app} ein.`,
     einladungValid: (validUntil) => `Der Link funktioniert einmal und ist bis ${validUntil} gültig.`,
+    welcomeBack: "Willkommen zurück",
+    logInTo: (app) => `Bei ${app} anmelden`,
+    forgotPassword: "Passwort vergessen?",
+    forgotIntro: "Gib deine E-Mail-Adresse ein, dann schicken wir dir einen Link zum Zurücksetzen.",
+    email: "E-Mail",
+    emailPlaceholder: "du@beispiel.ch",
+    password: "Passwort",
+    sendTheLink: "Link schicken",
+    backToLogin: "Zurück zur Anmeldung",
+    orWithEmail: "oder mit E-Mail",
+    logIn: "Anmelden",
+    noAccountYet: "Noch kein Konto?",
+    signUp: "Registrieren",
+    continueWith: (provider) => `Weiter mit ${provider}`,
+    accountNotLinked: "Dieses Google- oder GitHub-Konto bestätigt deine E-Mail-Adresse nicht. Melde dich mit E-Mail und Passwort an und verknüpfe es in den Einstellungen.",
+    noNewAccountInvite: "Neue Konten brauchen eine Einladung. Frag jemanden, der schon ein Konto hat, nach einem Einladungslink.",
+    noNewAccountOpen: "Im Moment können keine Konten erstellt werden. Bitte versuch es später wieder.",
+    loginTooOld: "Deine Anmeldung ist älter als einen Tag. Melde dich für diese Aktion bitte neu an.",
+    confirmEmailFirst: "Bestätige zuerst deine E-Mail-Adresse: Wir haben dir gerade einen neuen Link geschickt.",
+    resetLinkNotSent: "Der Link zum Zurücksetzen konnte nicht verschickt werden.",
+    resetLinkSent: "Wenn es ein Konto mit dieser E-Mail-Adresse gibt, ist ein Link zum Zurücksetzen des Passworts unterwegs.",
+    resetLinkNotRequested: "Der Link zum Zurücksetzen konnte nicht angefordert werden.",
+    invalidEmailDot: "Bitte gib eine gültige E-Mail-Adresse ein.",
+    twoFactorTitle: "Zwei-Faktor-Authentisierung",
+    twoFactorEnterCode: "Gib den 6-stelligen Code aus deiner Authenticator-App ein.",
+    confirm: "Bestätigen",
+    cancel: "Abbrechen",
+    invalidCode: "Bitte gib einen gültigen 6-stelligen Code ein.",
+    wrongCode: "Falscher oder abgelaufener Code.",
+    codeNotVerified: "Der Code konnte nicht geprüft werden.",
+    createAccount: "Konto erstellen",
+    invitesYouTo: (inviter, app) => `${inviter} lädt dich zu ${app} ein.`,
+    signUpWith: (providers) => `Registrieren mit ${providers} oder mit E-Mail und Passwort`,
+    or: "oder",
+    almostDone: (email, app) => `Fast geschafft: Wenn ${email} für ${app} verwendet werden kann, ist ein Link zur Bestätigung unterwegs. Öffne ihn, um ${app} zu benutzen.`,
+    accountReady: "Dein Konto ist bereit.",
+    inviteOnly: (app) => `${app} gibt es nur auf Einladung. Frag jemanden, der schon ein Konto hat, nach einem Einladungslink und öffne ihn auf diesem Gerät.`,
+    alreadyHaveAccount: "Schon ein Konto?",
+    repeatPassword: "Passwort wiederholen",
+    passwordsDontMatchDot: "Die Passwörter stimmen nicht überein.",
+    needsValidEinladung: "Zum Registrieren braucht es eine gültige Einladung.",
+    emailInUse: "Diese E-Mail-Adresse wird schon verwendet.",
+    signupFailed: "Die Registrierung hat nicht geklappt.",
+    resetTitle: "Passwort zurücksetzen",
+    resetIntro: "Gib dein neues Passwort ein",
+    resetNoToken: "Kein gültiger Link. Bitte fordere einen neuen Link zum Zurücksetzen an.",
+    resetLinkInvalid: "Der Link zum Zurücksetzen ist ungültig oder unvollständig.",
+    passwordTooShortDot: (min) => `Das Passwort braucht mindestens ${min} Zeichen.`,
+    newPassword: "Neues Passwort",
+    confirmNewPassword: "Neues Passwort bestätigen",
+    savePassword: "Passwort speichern",
+    passwordNotReset: "Das Passwort konnte nicht zurückgesetzt werden.",
+    passwordWasReset: "Passwort zurückgesetzt. Du kannst dich jetzt anmelden.",
+    somethingWentWrong: "Etwas ist schiefgelaufen.",
+    invitationTitle: "Einladung",
+    invitationTo: (app) => `Einladung zu ${app}`,
+    invitesYou: (inviter) => `${inviter} lädt dich ein.`,
+    askForNewLink: "Bitte frag nach einem neuen Link.",
+    toStartPage: "Zur Startseite",
+    alreadyHaveAccountNoInvite: "Du hast schon ein Konto; diese Einladung brauchst du nicht.",
+    openApp: (app) => `${app} öffnen`,
+    iHaveAnAccount: "Ich habe schon ein Konto",
+    settingsTitle: "Einstellungen",
+    backToOverview: "Zurück zur Übersicht",
+    user: "Konto",
+    profile: "Profil",
+    memberSince: (since) => `Dabei seit ${since}`,
+    tabProfile: "Profil",
+    tabProfileHint: "Name und E-Mail",
+    tabSecurity: "Sicherheit",
+    tabSecurityHint: "Passwort und Zwei-Faktor-Authentisierung",
+    tabSessions: "Sitzungen",
+    tabSessionsHint: "Geräte, auf denen du angemeldet bist",
+    tabLinks: "Verknüpfte Konten",
+    tabLinksHint: "Anmeldung mit GitHub und Google",
+    tabInvitations: "Einladungen",
+    tabInvitationsHint: "Jemanden einladen",
+    tabDeletion: "Konto löschen",
+    tabDeletionHint: "Dein Konto endgültig löschen",
+    name: "Name",
+    yourName: "Dein Name",
+    save: "Speichern",
+    saving: "Wird gespeichert…",
+    profileUpdated: "Profil gespeichert",
+    profileNotUpdated: "Das Profil konnte nicht gespeichert werden",
+    loadingSecurity: "Sicherheitseinstellungen werden geladen…",
+    changePassword: "Passwort ändern",
+    changing: "Wird geändert…",
+    passwordChanged: "Passwort geändert",
+    passwordNotChanged: "Das Passwort konnte nicht geändert werden",
+    currentPassword: "Aktuelles Passwort",
+    confirmNewPasswordShort: "Neues Passwort bestätigen",
+    setPassword: "Passwort festlegen",
+    setPasswordIntro: "Dein Konto hat noch kein Passwort. Lege eines fest, um dich auch mit E-Mail und Passwort anzumelden und die Zwei-Faktor-Authentisierung zu nutzen.",
+    setPasswordButton: "Passwort festlegen",
+    passwordSet: "Passwort festgelegt",
+    passwordNotSet: "Das Passwort konnte nicht festgelegt werden",
+    twoFactorHeading: "Zwei-Faktor-Authentisierung (2FA)",
+    twoFactorIntro: "Schütze dein Konto mit einem Einmalcode aus einer Authenticator-App.",
+    on: "Ein",
+    off: "Aus",
+    twoFactorProtects: "Die Zwei-Faktor-Authentisierung schützt dein Konto. Gib dein Passwort ein, um sie auszuschalten.",
+    yourPassword: "Dein Passwort",
+    turningOff: "Wird ausgeschaltet…",
+    turnOff: "Ausschalten",
+    turnOff2fa: "2FA ausschalten",
+    scanQr: "QR-Code scannen",
+    qrAlt: "QR-Code für die Authenticator-App",
+    scanWithApp: "Scanne diesen Code mit deiner Authenticator-App (z. B. Google Authenticator, Authy, Bitwarden).",
+    saveBackupCodes: "1. Ersatzcodes sichern",
+    backupCodesIntro: "Bewahre diese Einmalcodes sicher auf. Mit jedem kannst du dich einmal anmelden, wenn du keinen Zugriff auf dein Telefon hast.",
+    copyBackupCodes: "Ersatzcodes kopieren",
+    backupCodesCopied: "Ersatzcodes kopiert",
+    confirmSetup: "2. Einrichtung bestätigen",
+    enterCodeFromApp: "Gib den 6-stelligen Code aus der App ein",
+    checking: "Wird geprüft…",
+    turnOn2fa: "2FA einschalten",
+    setup2faIntro: "Gib zum Einrichten von 2FA dein Passwort ein, damit wir wissen, dass du es bist.",
+    starting: "Wird gestartet…",
+    start2faSetup: "2FA einrichten",
+    enterPasswordOn: "Bitte gib dein Passwort ein, um 2FA einzuschalten.",
+    enterPasswordOff: "Bitte gib dein Passwort ein, um 2FA auszuschalten.",
+    twoFactorNotOn: "2FA konnte nicht eingeschaltet werden",
+    twoFactorNotOff: "2FA konnte nicht ausgeschaltet werden",
+    twoFactorIsOn: "Die Zwei-Faktor-Authentisierung ist eingeschaltet.",
+    twoFactorIsOff: "2FA ist ausgeschaltet.",
+    setupNotStarted: "Die Einrichtung von 2FA konnte nicht gestartet werden",
+    activeSessions: "Aktive Sitzungen",
+    devicesLoggedIn: "Die Geräte, auf denen du angemeldet bist.",
+    endAllOthers: "Alle anderen beenden",
+    noActiveSessions: "Keine aktiven Sitzungen.",
+    unknownBrowser: "Unbekannter Browser",
+    thisSession: "Diese Sitzung",
+    noIpAddress: "Keine IP-Adresse",
+    lastActive: (when) => `Zuletzt aktiv: ${when}`,
+    unknown: "Unbekannt",
+    sessionEnded: "Sitzung beendet",
+    sessionNotEnded: "Die Sitzung konnte nicht beendet werden",
+    otherSessionsEnded: "Andere Sitzungen beendet",
+    otherSessionsNotEnded: "Die anderen Sitzungen konnten nicht beendet werden",
+    linkedAccounts: "Verknüpfte Konten",
+    linkedIntro: "Melde dich auch mit GitHub oder Google bei deinem Konto an.",
+    linked: "Verknüpft",
+    notLinked: "Nicht verknüpft",
+    unlink: "Trennen",
+    link: "Verknüpfen",
+    noSocialLogin: "Auf diesem Server ist keine Anmeldung mit GitHub oder Google eingerichtet.",
+    autoLinkNote: "Meldest du dich mit GitHub oder Google an und bestätigt der Anbieter dieselbe E-Mail-Adresse wie bei deinem Konto, werden die beiden automatisch verknüpft.",
+    providerLinked: (provider) => `${provider} verknüpft`,
+    providerUnlinked: (provider) => `${provider} getrennt`,
+    providerNotLinked: (provider) => `${provider} konnte nicht verknüpft werden`,
+    providerNotUnlinked: (provider) => `${provider} konnte nicht getrennt werden`,
+    inviteSomeone: "Jemanden einladen",
+    inviteIntro: "Ein Einladungslink funktioniert einmal und 14 Tage lang. Wer ihn öffnet, kann ein Konto erstellen.",
+    linkWord: "Link",
+    validUntil: (date) => `gültig bis ${date}`,
+    withdrawInvitation: "Einladung zurückziehen",
+    invitationWithdrawn: "Einladung zurückgezogen",
+    invitationNotWithdrawn: "Die Einladung konnte nicht zurückgezogen werden.",
+    emailOptional: "E-Mail (freiwillig, sonst nur ein Link)",
+    creating: "Wird erstellt…",
+    createInvitation: "Einladung erstellen",
+    copy: "Kopieren",
+    share: "Teilen",
+    linkShownOnce: "Der Link wird nur jetzt angezeigt. Schick ihn per Nachricht oder E-Mail.",
+    invitationText: (app, link) => `Ich lade dich zu ${app} ein: ${link}`,
+    shareYourself: (error) => `${error}. Teile den Link stattdessen selbst.`,
+    invitationSentTo: (email) => `Einladung an ${email} geschickt`,
+    invitationNotCreated: "Die Einladung konnte nicht erstellt werden.",
+    linkCopied: "Link kopiert",
+    copyLinkFailed: "Kopieren hat nicht geklappt; markiere den Link und kopiere ihn von Hand.",
+    deleteForGood: "Dein Konto endgültig löschen",
+    cannotBeUndone: "Das lässt sich nicht rückgängig machen",
+    deletionText: "Dein Konto wird mit allem gelöscht, was dazugehört, auch deinen Einladungen und Sitzungen.",
+    deletionAgents: "Verbundene KI-Assistenten verlieren ihren Zugriff.",
+    deletionNoLogin: "Danach kannst du dich nicht mehr anmelden.",
+    typeToContinue: "ein, um fortzufahren:",
+    type: "Gib",
+    deleteWord: "LÖSCHEN",
+    deleting: "Wird gelöscht…",
+    deletePermanently: "Konto endgültig löschen",
+    accountDeleted: "Dein Konto ist gelöscht.",
+    accountNotDeleted: "Das Konto konnte nicht gelöscht werden.",
+    administration: "Verwaltung",
+    accounts: "Konten",
+    since: (date) => `seit ${date}`,
+    you: "(du)",
+    roleOf: (name) => `Rolle von ${name}`,
+    roleChanged: "Rolle geändert",
+    deleteAccountOf: (name) => `Konto von ${name} löschen`,
+    confirmDeleteAccount: (name) => `Das Konto von ${name} mit allen Daten löschen? Das lässt sich nicht rückgängig machen.`,
+    accountDeletedAdmin: "Konto gelöscht",
+    invitations: "Einladungen",
+    noOpenInvitations: "Keine offenen Einladungen.",
+    by: (inviter) => `von ${inviter}`,
+    didntWork: "Das hat nicht geklappt.",
 };
 let current = en;
 export function configureAuthMessages({ locale, overrides }) {

package/dist/ui/AdminView.svelte

@@ -0,0 +1,91 @@
+<script lang="ts">
+	import { Trash2, X } from "@lucide/svelte";
+	import { toast } from "svelte-sonner";
+	import { m } from "../messages.js";
+	import { deleteUser, getAllUsers, setUserRole } from "../remote/app_user.remote.js";
+	import { adminWithdrawEinladung, getAlleEinladungen } from "../remote/einladung.remote.js";
+	import { authUi } from "./context.js";
+	import EinladungErstellen from "./EinladungErstellen.svelte";
+	import { messageOf } from "../util/messageOf.js";
+
+	/** The app admin: accounts (role, delete), new Einladungen and every open one. No impersonation, no access to anyone's data. */
+	let { currentUserId }: { currentUserId: string } = $props();
+	const { locale } = authUi();
+
+	const users = $derived(await getAllUsers());
+	const einladungen = $derived(await getAlleEinladungen());
+	const datum = new Intl.DateTimeFormat(locale, { dateStyle: "medium" });
+
+	async function run(action: () => Promise<unknown>, success: string) {
+		try {
+			await action();
+			toast.success(success);
+		} catch (e) {
+			toast.error(messageOf(e, m().didntWork));
+		}
+	}
+
+	function remove(id: string, name: string) {
+		if (!confirm(m().confirmDeleteAccount(name))) return;
+		run(() => deleteUser({ userId: id }), m().accountDeletedAdmin);
+	}
+</script>
+
+<div class="mx-auto grid max-w-3xl gap-6">
+	<header>
+		<span class="section-kicker">{m().administration}</span>
+		<h1 class="text-2xl font-semibold tracking-tight">{m().accounts}</h1>
+	</header>
+
+	<section class="panel p-5">
+		<ul class="grid gap-3">
+			{#each users as u (u.id)}
+				<li class="flex items-center gap-3">
+					<div class="grid min-w-0 flex-1">
+						<strong class="truncate text-sm font-semibold">{u.name}</strong>
+						<small class="text-xs text-muted-foreground">{u.email} · {m().since(datum.format(new Date(u.createdAt)))}{u.twoFactorEnabled ? " · 2FA" : ""}</small>
+					</div>
+					{#if u.id === currentUserId}
+						<span class="text-xs text-muted-foreground">{u.role} {m().you}</span>
+					{:else}
+						<select
+							value={u.role}
+							aria-label={m().roleOf(u.name)}
+							class="rounded-md border bg-background px-2 py-1.5 text-xs"
+							onchange={(e) => run(() => setUserRole({ userId: u.id, role: e.currentTarget.value as "admin" | "user" }), m().roleChanged)}
+						>
+							<option value="user">user</option>
+							<option value="admin">admin</option>
+						</select>
+						<button type="button" class="text-muted-foreground hover:text-destructive" aria-label={m().deleteAccountOf(u.name)} onclick={() => remove(u.id, u.name)}>
+							<Trash2 size={15} />
+						</button>
+					{/if}
+				</li>
+			{/each}
+		</ul>
+	</section>
+
+	<section class="panel grid gap-3 p-5">
+		<span class="section-kicker">{m().invitations}</span>
+		<p class="text-sm text-muted-foreground">{m().inviteIntro}</p>
+		<EinladungErstellen />
+		{#if einladungen.length === 0}
+			<p class="text-sm text-muted-foreground">{m().noOpenInvitations}</p>
+		{:else}
+			<ul class="grid gap-3">
+				{#each einladungen as e (e.id)}
+					<li class="flex items-center gap-3">
+						<div class="grid min-w-0 flex-1">
+							<strong class="truncate text-sm font-semibold">{e.email ?? m().linkWord}</strong>
+							<small class="text-xs text-muted-foreground">{m().by(e.inviterName)} · {m().validUntil(datum.format(new Date(e.expiresAt)))}</small>
+						</div>
+						<button type="button" class="text-muted-foreground hover:text-destructive" aria-label={m().withdrawInvitation} onclick={() => run(() => adminWithdrawEinladung({ einladungId: e.id }), m().invitationWithdrawn)}>
+							<X size={15} />
+						</button>
+					</li>
+				{/each}
+			</ul>
+		{/if}
+	</section>
+</div>

package/dist/ui/AdminView.svelte.d.ts

@@ -0,0 +1,6 @@
+type $$ComponentProps = {
+    currentUserId: string;
+};
+declare const AdminView: import("svelte").Component<$$ComponentProps, {}, "">;
+type AdminView = ReturnType<typeof AdminView>;
+export default AdminView;

package/dist/ui/ChangePasswordCard.svelte

@@ -0,0 +1,62 @@
+<script lang="ts">
+	import { KeyRound } from "@lucide/svelte";
+	import { toast } from "svelte-sonner";
+	import { Button } from "../components/ui/button/index.js";
+	import { Input } from "../components/ui/input/index.js";
+	import { Label } from "../components/ui/label/index.js";
+	import { m } from "../messages.js";
+	import { changePassword } from "../remote/app_user.remote.js";
+	import { messageOf } from "../util/messageOf.js";
+
+	let isSubmitting = $state(false);
+</script>
+
+<div class="panel p-6 md:p-8">
+	<h3 class="mb-6 flex items-center gap-2 text-lg font-semibold">
+		<KeyRound class="size-5 text-muted-foreground" />
+		{m().changePassword}
+	</h3>
+	<form
+		class="space-y-6"
+		{...changePassword.enhance(async ({ submit }) => {
+			isSubmitting = true;
+			try {
+				await submit();
+				toast.success(m().passwordChanged);
+				changePassword.fields.currentPassword.set("");
+				changePassword.fields.newPassword.set("");
+				changePassword.fields.confirmPassword.set("");
+			} catch (e) {
+				toast.error(messageOf(e, m().passwordNotChanged));
+			} finally {
+				isSubmitting = false;
+			}
+		})}
+	>
+		<div class="space-y-2">
+			<Label for="currentPassword" class="text-sm font-medium">{m().currentPassword}</Label>
+			<Input id="currentPassword" type="password" {...changePassword.fields.currentPassword.as("text")} placeholder="••••••••" class="bg-muted/30" />
+			{#each changePassword.fields.currentPassword.issues() as issue (issue.message)}
+				<p class="text-sm text-destructive">{issue.message}</p>
+			{/each}
+		</div>
+
+		<div class="space-y-2">
+			<Label for="newPassword" class="text-sm font-medium">{m().newPassword}</Label>
+			<Input id="newPassword" type="password" {...changePassword.fields.newPassword.as("text")} placeholder="••••••••" class="bg-muted/30" />
+			{#each changePassword.fields.newPassword.issues() as issue (issue.message)}
+				<p class="text-sm text-destructive">{issue.message}</p>
+			{/each}
+		</div>
+
+		<div class="space-y-2">
+			<Label for="confirmPassword" class="text-sm font-medium">{m().confirmNewPasswordShort}</Label>
+			<Input id="confirmPassword" type="password" {...changePassword.fields.confirmPassword.as("text")} placeholder="••••••••" class="bg-muted/30" />
+			{#each changePassword.fields.confirmPassword.issues() as issue (issue.message)}
+				<p class="text-sm text-destructive">{issue.message}</p>
+			{/each}
+		</div>
+
+		<Button type="submit" class="cursor-pointer" disabled={isSubmitting}>{isSubmitting ? m().changing : m().changePassword}</Button>
+	</form>
+</div>

package/dist/ui/ChangePasswordCard.svelte.d.ts

@@ -0,0 +1,3 @@
+declare const ChangePasswordCard: import("svelte").Component<Record<string, never>, {}, "">;
+type ChangePasswordCard = ReturnType<typeof ChangePasswordCard>;
+export default ChangePasswordCard;

package/dist/ui/DeletionTab.svelte

@@ -0,0 +1,76 @@
+<script lang="ts">
+	import { AlertTriangle, Trash2 } from "@lucide/svelte";
+	import { toast } from "svelte-sonner";
+	import { Button } from "../components/ui/button/index.js";
+	import { Input } from "../components/ui/input/index.js";
+	import { Label } from "../components/ui/label/index.js";
+	import * as Tabs from "../components/ui/tabs/index.js";
+	import { m } from "../messages.js";
+	import { deleteOwnAccount } from "../remote/app_user.remote.js";
+	import { authUi } from "./context.js";
+	import { messageOf } from "../util/messageOf.js";
+
+	/** Deleting the own account; `agents` adds the sentence about connected AI assistants (the MCP endpoint). */
+	let { agents = false }: { agents?: boolean } = $props();
+	const { authClient } = authUi();
+
+	let confirmationText = $state("");
+	let isSubmitting = $state(false);
+
+	const isConfirmed = $derived(confirmationText.toLowerCase() === m().deleteWord.toLowerCase());
+
+	async function handleDeleteAccount() {
+		if (!isConfirmed) return;
+		isSubmitting = true;
+		try {
+			const res = await deleteOwnAccount();
+			if (res.success) {
+				toast.success(m().accountDeleted);
+				await authClient.signOut().catch(() => undefined);
+				window.location.href = "/";
+			} else {
+				toast.error(m().accountNotDeleted);
+			}
+		} catch (error) {
+			toast.error(messageOf(error, m().accountNotDeleted));
+		} finally {
+			isSubmitting = false;
+		}
+	}
+</script>
+
+<Tabs.Content value="deletion" class="mt-6 space-y-6">
+	<div class="rounded-xl border border-destructive/20 bg-destructive/5 p-8 shadow-sm dark:bg-destructive/10">
+		<h3 class="mb-4 flex items-center gap-2 text-lg font-semibold text-destructive">
+			<Trash2 class="size-5" />
+			{m().deleteForGood}
+		</h3>
+
+		<div class="max-w-2xl space-y-4 text-sm leading-relaxed text-muted-foreground">
+			<div class="flex gap-3 rounded-lg border border-destructive/25 bg-destructive/10 p-4 text-destructive dark:bg-destructive/20 dark:text-destructive">
+				<AlertTriangle class="mt-0.5 size-5 shrink-0" />
+				<div>
+					<h4 class="mb-1 font-semibold">{m().cannotBeUndone}</h4>
+					<p>
+						{m().deletionText}
+						{#if agents}{m().deletionAgents}{/if}
+						{m().deletionNoLogin}
+					</p>
+				</div>
+			</div>
+
+			<div class="space-y-2 pt-2">
+				<Label for="confirm-text" class="font-medium text-foreground">
+					{m().type} <span class="font-bold text-destructive">{m().deleteWord}</span> {m().typeToContinue}
+				</Label>
+				<Input id="confirm-text" type="text" bind:value={confirmationText} placeholder={m().deleteWord} class="max-w-md border-destructive/30 bg-background focus-visible:ring-destructive" disabled={isSubmitting} />
+			</div>
+
+			<div class="pt-4">
+				<Button variant="destructive" disabled={!isConfirmed || isSubmitting} onclick={handleDeleteAccount} class="cursor-pointer">
+					{isSubmitting ? m().deleting : m().deletePermanently}
+				</Button>
+			</div>
+		</div>
+	</div>
+</Tabs.Content>