@phis/ui 0.1.0 → 0.2.1

package/components/widgets/label-sets/security.js

@@ -0,0 +1,81 @@
+import "server-only";
+import { PHI_TR_CTX_WEB_UI_LABEL } from "../../../gateway/tr";
+import { definePhiLabelSet, definePhiMessageLabel, getPhiLabelSet } from "../../../gateway/label-set";
+/**
+ * What the account security Widget says.
+ *
+ * It said all of it in hard-coded English until now -- on a page about somebody's own account, on a Site
+ * that may not be English at all. Sentences and captions are kept apart the way the table's set keeps
+ * them: `definePhiMessageLabel` for what the Widget says, a plain string for what it labels.
+ */
+const PHI_AUTH_SECURITY_WIDGET_LABEL_SET = definePhiLabelSet({
+    key: "widget:auth-security",
+    ctx: PHI_TR_CTX_WEB_UI_LABEL,
+    labels: {
+        intro: definePhiMessageLabel("Manage authenticator apps, linked login providers, and sessions for this site."),
+        error_unavailable: definePhiMessageLabel("Account security is unavailable."),
+        error_load_failed: definePhiMessageLabel("Account security could not be loaded."),
+        error_csrf_failed: definePhiMessageLabel("Could not initialize authentication session."),
+        error_factor_remove_failed: definePhiMessageLabel("Authentication factor could not be removed."),
+        error_session_revoke_failed: definePhiMessageLabel("Session could not be revoked."),
+        authenticators_title: "Authenticator apps",
+        authenticators_add: "Add authenticator",
+        authenticators_empty: definePhiMessageLabel("No authenticator configured."),
+        authenticators_unnamed: "Authenticator app",
+        authenticators_last_used: definePhiMessageLabel("Last used %1"),
+        authenticators_never_used: definePhiMessageLabel("Not used yet"),
+        authenticators_required: "Required",
+        authenticators_remove_confirm: definePhiMessageLabel("Remove this authenticator?"),
+        authenticators_remove: "Remove",
+        providers_title: "Linked login providers",
+        providers_empty: definePhiMessageLabel("No external login provider linked."),
+        sessions_title: "Sessions",
+        sessions_empty: definePhiMessageLabel("No sessions recorded."),
+        sessions_current: "Current session",
+        sessions_other: "Session",
+        sessions_no_device_details: definePhiMessageLabel("No device details"),
+        sessions_revoked: "Revoked",
+        sessions_active: "Active",
+        sessions_revoke_confirm: definePhiMessageLabel("Revoke this session?"),
+        sessions_revoke: "Revoke",
+    },
+});
+export async function getPhiAuthSecurityWidgetLabels(options) {
+    const labels = await getPhiLabelSet(options, PHI_AUTH_SECURITY_WIDGET_LABEL_SET);
+    return {
+        intro: labels.intro,
+        errors: {
+            unavailable: labels.error_unavailable,
+            loadFailed: labels.error_load_failed,
+            csrfFailed: labels.error_csrf_failed,
+            factorRemoveFailed: labels.error_factor_remove_failed,
+            sessionRevokeFailed: labels.error_session_revoke_failed,
+        },
+        authenticators: {
+            title: labels.authenticators_title,
+            add: labels.authenticators_add,
+            empty: labels.authenticators_empty,
+            unnamed: labels.authenticators_unnamed,
+            lastUsed: labels.authenticators_last_used,
+            neverUsed: labels.authenticators_never_used,
+            required: labels.authenticators_required,
+            removeConfirm: labels.authenticators_remove_confirm,
+            remove: labels.authenticators_remove,
+        },
+        providers: {
+            title: labels.providers_title,
+            empty: labels.providers_empty,
+        },
+        sessions: {
+            title: labels.sessions_title,
+            empty: labels.sessions_empty,
+            current: labels.sessions_current,
+            other: labels.sessions_other,
+            noDeviceDetails: labels.sessions_no_device_details,
+            revoked: labels.sessions_revoked,
+            active: labels.sessions_active,
+            revokeConfirm: labels.sessions_revoke_confirm,
+            revoke: labels.sessions_revoke,
+        },
+    };
+}

package/components/widgets/label-sets/session.d.ts

@@ -0,0 +1,6 @@
+import "server-only";
+import { type PhiGlobalTranslatorOptions } from "../../../gateway/tr";
+export type PhiSessionLabels = {
+    signOutFailed: string;
+};
+export declare function getPhiSessionLabels(options: PhiGlobalTranslatorOptions): Promise<PhiSessionLabels>;

package/components/widgets/label-sets/session.js

@@ -0,0 +1,20 @@
+import "server-only";
+import { PHI_TR_CTX_WEB_UI_LABEL } from "../../../gateway/tr";
+import { definePhiLabelSet, definePhiMessageLabel, getPhiLabelSet } from "../../../gateway/label-set";
+/**
+ * What the Core Runtime Controller says about a session it was asked to end.
+ *
+ * Only the failure: a sign-out that worked is answered by the fresh document that follows it, and
+ * one that did not must say so -- the person asked to be signed out and is still signed in.
+ */
+const PHI_SESSION_LABEL_SET = definePhiLabelSet({
+    key: "runtime:session",
+    ctx: PHI_TR_CTX_WEB_UI_LABEL,
+    labels: {
+        sign_out_failed: definePhiMessageLabel("You could not be signed out. Please try again."),
+    },
+});
+export async function getPhiSessionLabels(options) {
+    const labels = await getPhiLabelSet(options, PHI_SESSION_LABEL_SET);
+    return { signOutFailed: labels.sign_out_failed };
+}

package/components/widgets/label-sets/threads.d.ts

@@ -0,0 +1,96 @@
+import "server-only";
+import { type PhiGlobalTranslatorOptions } from "../../../gateway/tr";
+export declare function getPhiThreadPageLabels(options: PhiGlobalTranslatorOptions): Promise<{
+    title: string;
+    description: string;
+    inboxTitle: string;
+    inboxEmpty: string;
+    inboxEmptyHint: string;
+    newConversationLabel: string;
+    openConversationLabel: string;
+    cancelLabel: string;
+    composerLabel: string;
+    composerNoThreadText: string;
+    columns: {
+        subject: string;
+        kind: string;
+        state: string;
+        activity: string;
+    };
+    states: {
+        unread: string;
+        open: string;
+        archived: string;
+    };
+    kinds: {
+        direct: string;
+        group: string;
+        crossGroup: string;
+        support: string;
+    };
+    filters: {
+        unreadLabel: string;
+        statusLabel: string;
+        statusOpen: string;
+        statusArchived: string;
+    };
+    actions: {
+        archive: string;
+        reopen: string;
+        archiveConfirmTitle: string;
+        archiveConfirmText: string;
+        archiveConfirmOk: string;
+        confirmCancel: string;
+    };
+}>;
+export declare function getPhiThreadFormLabels(options: PhiGlobalTranslatorOptions): Promise<{
+    peopleLabel: string;
+    peoplePlaceholder: string;
+    peopleHint: string;
+    peopleRequired: string;
+    subjectLabel: string;
+    subjectPlaceholder: string;
+    subjectRequired: string;
+    messageLabel: string;
+    messagePlaceholder: string;
+    messageRequired: string;
+    replyLabel: string;
+    replyPlaceholder: string;
+    replyRequired: string;
+    replyThreadRequired: string;
+    replyAttachLabel: string;
+    replySendLabel: string;
+    replyAttachTooMany: string;
+    replyErrorGeneric: string;
+    replyErrorNetwork: string;
+    replyErrorTooLarge: string;
+    replyErrorDuplicate: string;
+    replyErrorTypeNotAllowed: string;
+    replyErrorQuotaExceeded: string;
+    replyErrorSpaceUnavailable: string;
+    replyErrorStorageUnreachable: string;
+}>;
+export declare function getPhiThreadConversationLabels(options: PhiGlobalTranslatorOptions): Promise<{
+    noThreadText: string;
+    loadingText: string;
+    emptyText: string;
+    subjectFallback: string;
+    olderLabel: string;
+    archivedLabel: string;
+    internalLabel: string;
+    translateLabel: string;
+    originalLabel: string;
+    machineTranslationLabel: string;
+    redactedText: string;
+    withheldText: string;
+    systemAuthorLabel: string;
+    unnamedAuthorLabel: string;
+    feedback: {
+        errorTitle: string;
+        errorGeneric: string;
+        errorNetwork: string;
+        errorNotFound: string;
+        errorTranslation: string;
+    };
+}>;
+export type PhiThreadConversationLabels = Awaited<ReturnType<typeof getPhiThreadConversationLabels>>;

package/components/widgets/label-sets/threads.js

@@ -0,0 +1,269 @@
+import "server-only";
+import { PHI_TR_CTX_WEB_UI_LABEL } from "../../../gateway/tr";
+import { definePhiLabelSet, definePhiMessageLabel, getPhiLabelSet } from "../../../gateway/label-set";
+const PHI_THREAD_CONVERSATION_LABEL_SET = definePhiLabelSet({
+    key: "widget:thread-conversation",
+    ctx: PHI_TR_CTX_WEB_UI_LABEL,
+    labels: {
+        no_thread_text: definePhiMessageLabel("Choose a conversation to read."),
+        loading_text: definePhiMessageLabel("Loading the conversation."),
+        empty_text: definePhiMessageLabel("Nothing has been said here yet."),
+        subject_fallback: "Conversation",
+        older_label: "Show earlier messages",
+        archived_label: "Archived",
+        /*
+         * Said on the note itself rather than in a legend somewhere.
+         *
+         * Staff write internal notes in the same place they write to the requester, and the one thing that
+         * must never be in doubt is which of the two a message is. A marker on the message is the only
+         * place a person actually looks while writing the next one.
+         */
+        internal_label: "Internal note",
+        /*
+         * One word for the control, because there is one control.
+         *
+         * The target language is not asked for: it is the language this person is reading in, and the button
+         * only appears where that language can actually be produced. A picker beside every message would have
+         * been a second control on every row for the sake of reading one message in a third language.
+         */
+        translate_label: "Translate",
+        original_label: "Show the original",
+        /*
+         * Said on the translation, because an unmarked one reads as what the person wrote.
+         *
+         * A machine translation carries a register nobody chose, and a support agent answering a sentence a
+         * machine put there has to know that is what they are looking at. The language it came out of stands
+         * beside it as its own name, where the provider reported one -- not woven into a sentence, which would
+         * fix a word order that only holds in English.
+         */
+        machine_translation_label: "Machine translation",
+        translation_error_text: definePhiMessageLabel("The translation could not be fetched."),
+        redacted_text: definePhiMessageLabel("This message was withdrawn."),
+        withheld_text: definePhiMessageLabel("This message is not shown to you."),
+        system_author_label: "System",
+        /* A projection carries a display name or nothing; nothing is still somebody. */
+        unnamed_author_label: "Someone",
+        error_title: "That did not work",
+        error_generic: definePhiMessageLabel("The conversation could not be loaded."),
+        error_network: definePhiMessageLabel("The site could not be reached."),
+        error_not_found: definePhiMessageLabel("This conversation is not there, or is not yours to read."),
+    },
+});
+/**
+ * What the Page around the three surfaces says.
+ *
+ * Its own set rather than a corner of the conversation's: this is the Page's title in a navigation
+ * menu and in a browser tab, and a Site that renames the Page renames one thing.
+ */
+const PHI_THREAD_PAGE_LABEL_SET = definePhiLabelSet({
+    key: "page:threads",
+    ctx: PHI_TR_CTX_WEB_UI_LABEL,
+    labels: {
+        title: "Conversations",
+        description: definePhiMessageLabel("Everything you are part of, and where to answer it."),
+        inbox_title: "Conversations",
+        inbox_empty: definePhiMessageLabel("Nothing yet. Start one."),
+        inbox_empty_hint: definePhiMessageLabel("Conversations you are part of appear here."),
+        new_conversation_label: "New conversation",
+        open_conversation_label: "Open conversation",
+        cancel_label: "Cancel",
+        composer_label: "Your answer",
+        /*
+         * The reply's button and the sentence that stands where the reply would be.
+         *
+         * Both belong to the Page rather than to the Form's own set: whether a reply is offered at all, what
+         * its button says and what stands there while nothing is chosen are decisions of this arrangement,
+         * and a Site that places the same Form elsewhere makes them again.
+         */
+        composer_no_thread_text: definePhiMessageLabel("Choose a conversation to write in."),
+        /*
+         * The listing is a Table, so what used to be a renderer's vocabulary is now column headings and
+         * the names a badge draws. They are here rather than in the Provider for the reason every visible
+         * word is: the Provider answers in numbers and runs in a browser, and a Site reads its own
+         * language.
+         */
+        column_subject: "Subject",
+        column_kind: "Kind",
+        column_state: "State",
+        column_activity: "Last activity",
+        state_unread: "New",
+        state_open: "Open",
+        state_archived: "Archived",
+        kind_direct: "Direct",
+        kind_group: "Group",
+        kind_cross_group: "Between groups",
+        kind_support: "Support",
+        filter_unread_label: "Unread only",
+        filter_status_label: "Status",
+        filter_status_open: "Open",
+        filter_status_archived: "Archived",
+        archive_label: "Archive",
+        reopen_label: "Reopen",
+        /*
+         * Archiving asks first because it reaches other people: one row carries the status, so the
+         * conversation closes for everyone in it. Reopening asks nothing, because it is the way back.
+         */
+        archive_confirm_title: "Archive this conversation?",
+        archive_confirm_text: definePhiMessageLabel("It closes for everyone in it. Anyone can reopen it later."),
+        archive_confirm_ok: "Archive",
+        confirm_cancel: "Cancel",
+    },
+});
+export async function getPhiThreadPageLabels(options) {
+    const labels = await getPhiLabelSet(options, PHI_THREAD_PAGE_LABEL_SET);
+    return {
+        title: labels.title,
+        description: labels.description,
+        inboxTitle: labels.inbox_title,
+        inboxEmpty: labels.inbox_empty,
+        inboxEmptyHint: labels.inbox_empty_hint,
+        newConversationLabel: labels.new_conversation_label,
+        openConversationLabel: labels.open_conversation_label,
+        cancelLabel: labels.cancel_label,
+        composerLabel: labels.composer_label,
+        composerNoThreadText: labels.composer_no_thread_text,
+        columns: {
+            subject: labels.column_subject,
+            kind: labels.column_kind,
+            state: labels.column_state,
+            activity: labels.column_activity,
+        },
+        states: {
+            unread: labels.state_unread,
+            open: labels.state_open,
+            archived: labels.state_archived,
+        },
+        kinds: {
+            direct: labels.kind_direct,
+            group: labels.kind_group,
+            crossGroup: labels.kind_cross_group,
+            support: labels.kind_support,
+        },
+        filters: {
+            unreadLabel: labels.filter_unread_label,
+            statusLabel: labels.filter_status_label,
+            statusOpen: labels.filter_status_open,
+            statusArchived: labels.filter_status_archived,
+        },
+        actions: {
+            archive: labels.archive_label,
+            reopen: labels.reopen_label,
+            archiveConfirmTitle: labels.archive_confirm_title,
+            archiveConfirmText: labels.archive_confirm_text,
+            archiveConfirmOk: labels.archive_confirm_ok,
+            confirmCancel: labels.confirm_cancel,
+        },
+    };
+}
+/**
+ * What the form that opens a conversation says.
+ *
+ * Its own set because a Form descriptor names one, and because these words belong to the form wherever
+ * it is placed -- the Page's set is about the Page. Everything a person reads while writing the first
+ * message is here, which is also what makes it translatable: the old panel carried its English inside
+ * a client component, where no translator could reach it.
+ */
+const PHI_THREAD_FORM_LABEL_SET = definePhiLabelSet({
+    key: "@phis/ui/modules/threads/labels/forms",
+    ctx: PHI_TR_CTX_WEB_UI_LABEL,
+    labels: {
+        people_label: "People",
+        people_placeholder: definePhiMessageLabel("Who is this with?"),
+        people_hint: definePhiMessageLabel("Everyone you name can read the whole conversation."),
+        people_required: definePhiMessageLabel("Choose at least one person."),
+        subject_label: "Subject",
+        subject_placeholder: definePhiMessageLabel("What is it about?"),
+        /*
+         * Asked for, although the column may be null.
+         *
+         * The subject names the whole chain -- the inbox row, the heading, what a notification is called --
+         * and a conversation without one is named after whoever is in it instead. An integration relaying a
+         * mail with an empty subject header cannot be held to this, which is why the database still allows
+         * none; a person opening one here can be.
+         */
+        subject_required: definePhiMessageLabel("Give the conversation a subject."),
+        message_label: "Message",
+        message_placeholder: definePhiMessageLabel("Write the first message"),
+        message_required: definePhiMessageLabel("A conversation starts with a message."),
+        /*
+         * The reply, in the same set as the conversation it opens.
+         *
+         * Two Forms, one vocabulary: a Site that translates "message" once should not meet it twice under
+         * different keys. The refusals an upload can produce are here for the same reason the Form's own
+         * are -- a file that was too large says so in the reader's language, and the shared English default
+         * in `upload-form-control.tsx` is what a Form without a label set falls back to, not what this one
+         * should show.
+         */
+        reply_label: "Your message",
+        reply_placeholder: definePhiMessageLabel("Write a message"),
+        reply_required: definePhiMessageLabel("Write something before you send it."),
+        reply_thread_required: definePhiMessageLabel("Choose a conversation first."),
+        reply_attach_label: "Attach a file",
+        reply_send_label: "Send",
+        reply_attach_too_many: definePhiMessageLabel("No more files fit here."),
+        reply_error_generic: definePhiMessageLabel("The file could not be attached."),
+        reply_error_network: definePhiMessageLabel("The site could not be reached."),
+        reply_error_too_large: definePhiMessageLabel("That file is too large."),
+        reply_error_duplicate: definePhiMessageLabel("That file is already attached."),
+        reply_error_type_not_allowed: definePhiMessageLabel("That kind of file cannot be attached."),
+        reply_error_quota_exceeded: definePhiMessageLabel("There is no room left in your space."),
+        reply_error_space_unavailable: definePhiMessageLabel("Files cannot be attached on this site."),
+        reply_error_storage_unreachable: definePhiMessageLabel("The file storage could not be reached."),
+    },
+});
+export async function getPhiThreadFormLabels(options) {
+    const labels = await getPhiLabelSet(options, PHI_THREAD_FORM_LABEL_SET);
+    return {
+        peopleLabel: labels.people_label,
+        peoplePlaceholder: labels.people_placeholder,
+        peopleHint: labels.people_hint,
+        peopleRequired: labels.people_required,
+        subjectLabel: labels.subject_label,
+        subjectPlaceholder: labels.subject_placeholder,
+        subjectRequired: labels.subject_required,
+        messageLabel: labels.message_label,
+        messagePlaceholder: labels.message_placeholder,
+        messageRequired: labels.message_required,
+        replyLabel: labels.reply_label,
+        replyPlaceholder: labels.reply_placeholder,
+        replyRequired: labels.reply_required,
+        replyThreadRequired: labels.reply_thread_required,
+        replyAttachLabel: labels.reply_attach_label,
+        replySendLabel: labels.reply_send_label,
+        replyAttachTooMany: labels.reply_attach_too_many,
+        replyErrorGeneric: labels.reply_error_generic,
+        replyErrorNetwork: labels.reply_error_network,
+        replyErrorTooLarge: labels.reply_error_too_large,
+        replyErrorDuplicate: labels.reply_error_duplicate,
+        replyErrorTypeNotAllowed: labels.reply_error_type_not_allowed,
+        replyErrorQuotaExceeded: labels.reply_error_quota_exceeded,
+        replyErrorSpaceUnavailable: labels.reply_error_space_unavailable,
+        replyErrorStorageUnreachable: labels.reply_error_storage_unreachable,
+    };
+}
+export async function getPhiThreadConversationLabels(options) {
+    const labels = await getPhiLabelSet(options, PHI_THREAD_CONVERSATION_LABEL_SET);
+    return {
+        noThreadText: labels.no_thread_text,
+        loadingText: labels.loading_text,
+        emptyText: labels.empty_text,
+        subjectFallback: labels.subject_fallback,
+        olderLabel: labels.older_label,
+        archivedLabel: labels.archived_label,
+        internalLabel: labels.internal_label,
+        translateLabel: labels.translate_label,
+        originalLabel: labels.original_label,
+        machineTranslationLabel: labels.machine_translation_label,
+        redactedText: labels.redacted_text,
+        withheldText: labels.withheld_text,
+        systemAuthorLabel: labels.system_author_label,
+        unnamedAuthorLabel: labels.unnamed_author_label,
+        feedback: {
+            errorTitle: labels.error_title,
+            errorGeneric: labels.error_generic,
+            errorNetwork: labels.error_network,
+            errorNotFound: labels.error_not_found,
+            errorTranslation: labels.translation_error_text,
+        },
+    };
+}

package/components/widgets/label-sets/unsubscribe.d.ts

@@ -0,0 +1,17 @@
+import "server-only";
+import { type PhiGlobalTranslatorOptions } from "../../../gateway/tr";
+export declare function getPhiUnsubscribeFormLabels(options: PhiGlobalTranslatorOptions): Promise<{
+    fields: {
+        token: {
+            required: string;
+        };
+    };
+    actions: {
+        submitLabel: string;
+    };
+    feedback: {
+        successTitle: string;
+        successText: string;
+        genericError: string;
+    };
+}>;

package/components/widgets/label-sets/unsubscribe.js

@@ -0,0 +1,39 @@
+import "server-only";
+import { PHI_TR_CTX_WEB_UI_LABEL } from "../../../gateway/tr";
+import { definePhiLabelSet, definePhiMessageLabel, getPhiLabelSet } from "../../../gateway/label-set";
+/**
+ * What the unsubscribe page says, in the language the mail was read in.
+ *
+ * Short by design: the page exists to be left, not read. The error carries the one thing worth saying about
+ * a link that no longer holds -- that a newer mail has a newer link -- because the alternative is somebody
+ * concluding they cannot get out.
+ */
+const PHI_UNSUBSCRIBE_FORM_LABEL_SET = definePhiLabelSet({
+    key: "widget:unsubscribe-form",
+    ctx: PHI_TR_CTX_WEB_UI_LABEL,
+    labels: {
+        token_required: definePhiMessageLabel("This unsubscribe link is incomplete."),
+        generic_error: definePhiMessageLabel("This link is no longer valid. The most recent message carries a working one."),
+        submit_label: "Unsubscribe",
+        success_title: "Unsubscribed",
+        success_text: definePhiMessageLabel("You will not receive further updates from this site. A message already on its way may still arrive."),
+    },
+});
+export async function getPhiUnsubscribeFormLabels(options) {
+    const labels = await getPhiLabelSet(options, PHI_UNSUBSCRIBE_FORM_LABEL_SET);
+    return {
+        fields: {
+            token: {
+                required: labels.token_required,
+            },
+        },
+        actions: {
+            submitLabel: labels.submit_label,
+        },
+        feedback: {
+            successTitle: labels.success_title,
+            successText: labels.success_text,
+            genericError: labels.generic_error,
+        },
+    };
+}

package/components/widgets/label-sets/video.d.ts

@@ -0,0 +1,11 @@
+import "server-only";
+import { type PhiGlobalTranslatorOptions } from "../../../gateway/tr";
+export declare function getPhiVideoWidgetLabels(options: PhiGlobalTranslatorOptions): Promise<{
+    loadLabel: string;
+    loadVisitLabel: string;
+    noticeText: string;
+    visitActiveText: string;
+    forgetLabel: string;
+    privacyLabel: string;
+}>;
+export type PhiVideoWidgetLabels = Awaited<ReturnType<typeof getPhiVideoWidgetLabels>>;

package/components/widgets/label-sets/video.js

@@ -0,0 +1,40 @@
+import "server-only";
+import { PHI_TR_CTX_WEB_UI_LABEL } from "../../../gateway/tr";
+import { definePhiLabelSet, definePhiMessageLabel, getPhiLabelSet } from "../../../gateway/label-set";
+/**
+ * What a placeholder says before a visitor has asked for anything.
+ *
+ * `notice_text` carries `%1` and the Control substitutes it. A label set holds plain text, so the
+ * alternative was a sentence broken into a prefix and a suffix -- which decides word order in English
+ * and then imposes it on every other language. The token lets the recipient sit where the sentence needs
+ * it, and a translator moves it there.
+ *
+ * `%1` rather than a readable `{recipient}`, and that is not a style choice: a translator translates
+ * words, so `{recipient}` came back from German as `{Empfänger}` and the placeholder showed a visitor
+ * the braces instead of the company. `%1` is not a word and survives the round trip -- the house token,
+ * the one every other label set sends ([helpers/text-placeholders.ts](../../../helpers/text-placeholders.ts)
+ * explains the same trap for Site copy).
+ */
+const PHI_VIDEO_WIDGET_LABEL_SET = definePhiLabelSet({
+    key: "widget:video",
+    ctx: PHI_TR_CTX_WEB_UI_LABEL,
+    labels: {
+        load_label: "Load video",
+        load_visit_label: "Load videos for this visit",
+        notice_text: definePhiMessageLabel("Loading this video sends a request to %1, which can recognise you there."),
+        visit_active_text: definePhiMessageLabel("Videos from %1 load without asking for the rest of this visit."),
+        forget_label: "Ask again",
+        privacy_label: "Privacy notice",
+    },
+});
+export async function getPhiVideoWidgetLabels(options) {
+    const labels = await getPhiLabelSet(options, PHI_VIDEO_WIDGET_LABEL_SET);
+    return {
+        loadLabel: labels.load_label,
+        loadVisitLabel: labels.load_visit_label,
+        noticeText: labels.notice_text,
+        visitActiveText: labels.visit_active_text,
+        forgetLabel: labels.forget_label,
+        privacyLabel: labels.privacy_label,
+    };
+}

package/components/widgets/label-types/auth-workflow.d.ts

@@ -0,0 +1,38 @@
+/**
+ * What the second-factor body says, in the language it is read in.
+ *
+ * It said all of it in hard-coded English, which was noticed the moment the body stopped taking a whole
+ * workflow: one sentence had been written for a sign-in that could not continue without a factor, and
+ * the App settings surface showed it to people who were adding an authenticator because they wanted one.
+ * A shared component with literal copy tells whichever caller it has least in common with the wrong
+ * thing, and it does so in one language.
+ *
+ * Grouped by the three things this body can be: reporting recovery codes, setting a device up, and
+ * asking for a code. `verify` is shared because the button says the same thing in two of them.
+ */
+export type PhiAuthWorkflowBodyLabels = {
+    errors: {
+        setupFailed: string;
+        verifyFailed: string;
+    };
+    /** Shown once a device is confirmed and the account has codes to keep. */
+    recovery: {
+        title: string;
+        description: string;
+        acknowledge: string;
+    };
+    enroll: {
+        title: string;
+        intro: string;
+        start: string;
+        codeAriaLabel: string;
+    };
+    challenge: {
+        title: string;
+        codePlaceholder: string;
+        recoveryPlaceholder: string;
+        useRecovery: string;
+        useAuthenticator: string;
+    };
+    verify: string;
+};