@oxyhq/core 9.2.4 → 10.1.0

package/dist/esm/utils/languageUtils.js

@@ -1,179 +1,212 @@
 /**
- * Language utilities for OxyServices
- * Provides access to supported languages and language metadata
+ * Locale utilities for OxyServices.
+ *
+ * The Oxy platform models account languages as full BCP-47 locales
+ * (`language-REGION`, e.g. `es-ES`, `es-MX`, `pt-BR`). Region is significant:
+ * "Spanish (Spain)" is a different locale than "Spanish (Mexico)". A user's
+ * account locales live on `User.languages` as an ordered list with the PRIMARY
+ * (UI) locale first — there is no singular `language` field.
+ *
+ * This module is the single source of truth for the supported-locale catalog
+ * and every locale operation the SDK exposes: parsing base subtags, canonical
+ * normalization, validation, metadata lookup, and resolving a user's locales.
+ * It is pure and side-effect free.
+ */
+/**
+ * The supported-locale catalog. Ordered by prominence for display; the order
+ * is not otherwise significant. Every entry is a full `language-REGION` tag,
+ * with the base subtag lowercased and the region uppercased.
  */
-// Supported languages with their metadata
 export const SUPPORTED_LANGUAGES = [
-    {
-        id: 'en-US',
-        name: 'English',
-        nativeName: 'English',
-        flag: '🇺🇸',
-        icon: 'translate',
-        color: '#007AFF',
-    },
-    {
-        id: 'es-ES',
-        name: 'Spanish',
-        nativeName: 'Español',
-        flag: '🇪🇸',
-        icon: 'translate',
-        color: '#FF3B30',
-    },
-    {
-        id: 'ca-ES',
-        name: 'Catalan',
-        nativeName: 'Català',
-        flag: '🇪🇸',
-        icon: 'translate',
-        color: '#0CA678',
-    },
-    {
-        id: 'fr-FR',
-        name: 'French',
-        nativeName: 'Français',
-        flag: '🇫🇷',
-        icon: 'translate',
-        color: '#5856D6',
-    },
-    {
-        id: 'de-DE',
-        name: 'German',
-        nativeName: 'Deutsch',
-        flag: '🇩🇪',
-        icon: 'translate',
-        color: '#FF9500',
-    },
-    {
-        id: 'it-IT',
-        name: 'Italian',
-        nativeName: 'Italiano',
-        flag: '🇮🇹',
-        icon: 'translate',
-        color: '#34C759',
-    },
-    {
-        id: 'pt-PT',
-        name: 'Portuguese',
-        nativeName: 'Português',
-        flag: '🇵🇹',
-        icon: 'translate',
-        color: '#AF52DE',
-    },
-    {
-        id: 'ja-JP',
-        name: 'Japanese',
-        nativeName: '日本語',
-        flag: '🇯🇵',
-        icon: 'translate',
-        color: '#FF2D92',
-    },
-    {
-        id: 'ko-KR',
-        name: 'Korean',
-        nativeName: '한국어',
-        flag: '🇰🇷',
-        icon: 'translate',
-        color: '#32D74B',
-    },
-    {
-        id: 'zh-CN',
-        name: 'Chinese',
-        nativeName: '中文',
-        flag: '🇨🇳',
-        icon: 'translate',
-        color: '#FF9F0A',
-    },
-    {
-        id: 'ar-SA',
-        name: 'Arabic',
-        nativeName: 'العربية',
-        flag: '🇸🇦',
-        icon: 'translate',
-        color: '#30B0C7',
-    },
+    // English
+    { code: 'en-US', language: 'en', region: 'US', name: 'English (United States)', nativeName: 'English (United States)' },
+    { code: 'en-GB', language: 'en', region: 'GB', name: 'English (United Kingdom)', nativeName: 'English (United Kingdom)' },
+    { code: 'en-AU', language: 'en', region: 'AU', name: 'English (Australia)', nativeName: 'English (Australia)' },
+    { code: 'en-CA', language: 'en', region: 'CA', name: 'English (Canada)', nativeName: 'English (Canada)' },
+    { code: 'en-IN', language: 'en', region: 'IN', name: 'English (India)', nativeName: 'English (India)' },
+    // Spanish
+    { code: 'es-ES', language: 'es', region: 'ES', name: 'Spanish (Spain)', nativeName: 'Español (España)' },
+    { code: 'es-MX', language: 'es', region: 'MX', name: 'Spanish (Mexico)', nativeName: 'Español (México)' },
+    { code: 'es-US', language: 'es', region: 'US', name: 'Spanish (United States)', nativeName: 'Español (Estados Unidos)' },
+    { code: 'es-AR', language: 'es', region: 'AR', name: 'Spanish (Argentina)', nativeName: 'Español (Argentina)' },
+    { code: 'es-CO', language: 'es', region: 'CO', name: 'Spanish (Colombia)', nativeName: 'Español (Colombia)' },
+    // Portuguese
+    { code: 'pt-BR', language: 'pt', region: 'BR', name: 'Portuguese (Brazil)', nativeName: 'Português (Brasil)' },
+    { code: 'pt-PT', language: 'pt', region: 'PT', name: 'Portuguese (Portugal)', nativeName: 'Português (Portugal)' },
+    // French
+    { code: 'fr-FR', language: 'fr', region: 'FR', name: 'French (France)', nativeName: 'Français (France)' },
+    { code: 'fr-CA', language: 'fr', region: 'CA', name: 'French (Canada)', nativeName: 'Français (Canada)' },
+    // German
+    { code: 'de-DE', language: 'de', region: 'DE', name: 'German (Germany)', nativeName: 'Deutsch (Deutschland)' },
+    { code: 'de-AT', language: 'de', region: 'AT', name: 'German (Austria)', nativeName: 'Deutsch (Österreich)' },
+    { code: 'de-CH', language: 'de', region: 'CH', name: 'German (Switzerland)', nativeName: 'Deutsch (Schweiz)' },
+    // Italian
+    { code: 'it-IT', language: 'it', region: 'IT', name: 'Italian (Italy)', nativeName: 'Italiano (Italia)' },
+    // Dutch
+    { code: 'nl-NL', language: 'nl', region: 'NL', name: 'Dutch (Netherlands)', nativeName: 'Nederlands (Nederland)' },
+    { code: 'nl-BE', language: 'nl', region: 'BE', name: 'Dutch (Belgium)', nativeName: 'Nederlands (België)' },
+    // Nordic
+    { code: 'sv-SE', language: 'sv', region: 'SE', name: 'Swedish (Sweden)', nativeName: 'Svenska (Sverige)' },
+    { code: 'nb-NO', language: 'nb', region: 'NO', name: 'Norwegian Bokmål (Norway)', nativeName: 'Norsk bokmål (Norge)' },
+    { code: 'da-DK', language: 'da', region: 'DK', name: 'Danish (Denmark)', nativeName: 'Dansk (Danmark)' },
+    { code: 'fi-FI', language: 'fi', region: 'FI', name: 'Finnish (Finland)', nativeName: 'Suomi (Suomi)' },
+    // Central & Eastern Europe
+    { code: 'pl-PL', language: 'pl', region: 'PL', name: 'Polish (Poland)', nativeName: 'Polski (Polska)' },
+    { code: 'cs-CZ', language: 'cs', region: 'CZ', name: 'Czech (Czechia)', nativeName: 'Čeština (Česko)' },
+    { code: 'sk-SK', language: 'sk', region: 'SK', name: 'Slovak (Slovakia)', nativeName: 'Slovenčina (Slovensko)' },
+    { code: 'hu-HU', language: 'hu', region: 'HU', name: 'Hungarian (Hungary)', nativeName: 'Magyar (Magyarország)' },
+    { code: 'ro-RO', language: 'ro', region: 'RO', name: 'Romanian (Romania)', nativeName: 'Română (România)' },
+    { code: 'bg-BG', language: 'bg', region: 'BG', name: 'Bulgarian (Bulgaria)', nativeName: 'Български (България)' },
+    { code: 'hr-HR', language: 'hr', region: 'HR', name: 'Croatian (Croatia)', nativeName: 'Hrvatski (Hrvatska)' },
+    { code: 'sr-RS', language: 'sr', region: 'RS', name: 'Serbian (Serbia)', nativeName: 'Српски (Србија)' },
+    { code: 'sl-SI', language: 'sl', region: 'SI', name: 'Slovenian (Slovenia)', nativeName: 'Slovenščina (Slovenija)' },
+    { code: 'lt-LT', language: 'lt', region: 'LT', name: 'Lithuanian (Lithuania)', nativeName: 'Lietuvių (Lietuva)' },
+    { code: 'lv-LV', language: 'lv', region: 'LV', name: 'Latvian (Latvia)', nativeName: 'Latviešu (Latvija)' },
+    { code: 'et-EE', language: 'et', region: 'EE', name: 'Estonian (Estonia)', nativeName: 'Eesti (Eesti)' },
+    { code: 'uk-UA', language: 'uk', region: 'UA', name: 'Ukrainian (Ukraine)', nativeName: 'Українська (Україна)' },
+    { code: 'ru-RU', language: 'ru', region: 'RU', name: 'Russian (Russia)', nativeName: 'Русский (Россия)' },
+    { code: 'el-GR', language: 'el', region: 'GR', name: 'Greek (Greece)', nativeName: 'Ελληνικά (Ελλάδα)' },
+    // Turkish
+    { code: 'tr-TR', language: 'tr', region: 'TR', name: 'Turkish (Türkiye)', nativeName: 'Türkçe (Türkiye)' },
+    // Catalan
+    { code: 'ca-ES', language: 'ca', region: 'ES', name: 'Catalan (Spain)', nativeName: 'Català (Espanya)' },
+    // East, South & Southeast Asia
+    { code: 'ja-JP', language: 'ja', region: 'JP', name: 'Japanese (Japan)', nativeName: '日本語 (日本)' },
+    { code: 'ko-KR', language: 'ko', region: 'KR', name: 'Korean (South Korea)', nativeName: '한국어 (대한민국)' },
+    { code: 'zh-CN', language: 'zh', region: 'CN', name: 'Chinese (Simplified, China)', nativeName: '中文 (中国)' },
+    { code: 'zh-TW', language: 'zh', region: 'TW', name: 'Chinese (Traditional, Taiwan)', nativeName: '中文 (台灣)' },
+    { code: 'zh-HK', language: 'zh', region: 'HK', name: 'Chinese (Traditional, Hong Kong)', nativeName: '中文 (香港)' },
+    { code: 'hi-IN', language: 'hi', region: 'IN', name: 'Hindi (India)', nativeName: 'हिन्दी (भारत)' },
+    { code: 'bn-BD', language: 'bn', region: 'BD', name: 'Bengali (Bangladesh)', nativeName: 'বাংলা (বাংলাদেশ)' },
+    { code: 'id-ID', language: 'id', region: 'ID', name: 'Indonesian (Indonesia)', nativeName: 'Bahasa Indonesia (Indonesia)' },
+    { code: 'ms-MY', language: 'ms', region: 'MY', name: 'Malay (Malaysia)', nativeName: 'Bahasa Melayu (Malaysia)' },
+    { code: 'th-TH', language: 'th', region: 'TH', name: 'Thai (Thailand)', nativeName: 'ไทย (ประเทศไทย)' },
+    { code: 'vi-VN', language: 'vi', region: 'VN', name: 'Vietnamese (Vietnam)', nativeName: 'Tiếng Việt (Việt Nam)' },
+    // Right-to-left
+    { code: 'ar-SA', language: 'ar', region: 'SA', name: 'Arabic (Saudi Arabia)', nativeName: 'العربية (السعودية)', rtl: true },
+    { code: 'ar-EG', language: 'ar', region: 'EG', name: 'Arabic (Egypt)', nativeName: 'العربية (مصر)', rtl: true },
+    { code: 'he-IL', language: 'he', region: 'IL', name: 'Hebrew (Israel)', nativeName: 'עברית (ישראל)', rtl: true },
+    { code: 'fa-IR', language: 'fa', region: 'IR', name: 'Persian (Iran)', nativeName: 'فارسی (ایران)', rtl: true },
+    { code: 'ur-PK', language: 'ur', region: 'PK', name: 'Urdu (Pakistan)', nativeName: 'اردو (پاکستان)', rtl: true },
 ];
-const FALLBACK_LANGUAGE = 'en-US';
+/** Canonical fallback locale used when a display value cannot be resolved. */
+export const FALLBACK_LOCALE = 'en-US';
+/** O(1) lookup of a catalog entry by its canonical code. */
+const LOCALE_BY_CODE = new Map(SUPPORTED_LANGUAGES.map((entry) => [entry.code, entry]));
 /**
- * Get language metadata by language code
- * @param languageCode - BCP-47 language code (e.g., 'en-US', 'es-ES')
- * @returns Language metadata or null if not found
+ * Extract the base language subtag from a locale, lowercased.
+ *
+ * Tolerant of bare base subtags and of extra subtags (script/variant):
+ * `'es-ES'` → `'es'`, `'es'` → `'es'`, `'zh-Hant-TW'` → `'zh'`. Returns an
+ * empty string for empty input.
  */
-export function getLanguageMetadata(languageCode) {
-    if (!languageCode)
-        return null;
-    // Direct match
-    const exactMatch = SUPPORTED_LANGUAGES.find(lang => lang.id === languageCode);
-    if (exactMatch)
-        return exactMatch;
-    // Try to match base language code (e.g., 'en' matches 'en-US')
-    const baseCode = languageCode.split('-')[0];
-    const baseMatch = SUPPORTED_LANGUAGES.find(lang => lang.id.startsWith(baseCode + '-'));
-    if (baseMatch)
-        return baseMatch;
-    return null;
+export function getBaseLanguage(locale) {
+    return locale.trim().toLowerCase().split('-')[0] ?? '';
 }
 /**
- * Get language name by language code
- * @param languageCode - BCP-47 language code (e.g., 'en-US', 'es-ES')
- * @returns Language name (e.g., 'English') or the code if not found
+ * Normalize a locale string to its canonical `language-REGION` form when it is
+ * a supported locale, otherwise `undefined`.
+ *
+ * Canonicalization lowercases the base subtag and uppercases the region
+ * subtag (`'es-es'` → `'es-ES'`, `'EN-us'` → `'en-US'`) and validates the
+ * result against {@link SUPPORTED_LANGUAGES}. A bare base subtag (`'es'`) has
+ * no region and is therefore not a locale — it returns `undefined`.
  */
-export function getLanguageName(languageCode) {
-    const metadata = getLanguageMetadata(languageCode);
-    return metadata?.name || languageCode || FALLBACK_LANGUAGE;
+export function normalizeLocale(input) {
+    const trimmed = input.trim();
+    if (!trimmed)
+        return undefined;
+    const parts = trimmed.split('-');
+    if (parts.length < 2)
+        return undefined;
+    const base = parts[0]?.toLowerCase();
+    const region = parts[parts.length - 1]?.toUpperCase();
+    if (!base || !region)
+        return undefined;
+    const canonical = `${base}-${region}`;
+    return LOCALE_BY_CODE.has(canonical) ? canonical : undefined;
 }
 /**
- * Get native language name by language code
- * @param languageCode - BCP-47 language code (e.g., 'en-US', 'es-ES')
- * @returns Native language name (e.g., 'Español') or the code if not found
+ * Whether `input` resolves to a supported BCP-47 locale.
  */
-export function getNativeLanguageName(languageCode) {
-    const metadata = getLanguageMetadata(languageCode);
-    return metadata?.nativeName || languageCode || FALLBACK_LANGUAGE;
+export function isSupportedLocale(input) {
+    return normalizeLocale(input) !== undefined;
 }
 /**
- * Normalize language code to BCP-47 format
- * @param lang - Language code (may be short like 'en' or full like 'en-US')
- * @returns Normalized BCP-47 language code
+ * Resolve catalog metadata for a locale.
+ *
+ * @param code - A locale tag (any case; e.g. `'es-ES'`, `'es-es'`).
+ * @returns The {@link SupportedLanguage} entry, or `null` when the tag is empty
+ *   or not a supported locale.
  */
-export function normalizeLanguageCode(lang) {
-    if (!lang)
-        return FALLBACK_LANGUAGE;
-    if (lang.includes('-'))
-        return lang;
-    const map = {
-        en: 'en-US',
-        es: 'es-ES',
-        ca: 'ca-ES',
-        fr: 'fr-FR',
-        de: 'de-DE',
-        it: 'it-IT',
-        pt: 'pt-PT',
-        ja: 'ja-JP',
-        ko: 'ko-KR',
-        zh: 'zh-CN',
-        ar: 'ar-SA',
-    };
-    return map[lang] || lang;
+export function getLanguageMetadata(code) {
+    if (!code)
+        return null;
+    const canonical = normalizeLocale(code);
+    if (!canonical)
+        return null;
+    return LOCALE_BY_CODE.get(canonical) ?? null;
 }
 /**
- * RTL language detection.
- *
- * Returns `true` when the given BCP-47 tag or bare language code is one
- * of the right-to-left scripts we ship UI for. Apps use this to drive
- * `I18nManager.allowRTL(true)` / `forceRTL(...)` on React Native and the
- * `<html dir="rtl">` attribute on web.
- *
- * Includes Arabic (`ar`), Hebrew (`he` / legacy `iw`), Persian (`fa`),
- * Urdu (`ur`) plus their common region variants. Unknown tags are
- * treated as LTR.
+ * English display name for a locale (e.g. `'Spanish (Spain)'`).
+ * Falls back to the input tag, then {@link FALLBACK_LOCALE}.
+ */
+export function getLanguageName(code) {
+    return getLanguageMetadata(code)?.name || code || FALLBACK_LOCALE;
+}
+/**
+ * Native display name (endonym) for a locale (e.g. `'Español (España)'`).
+ * Falls back to the input tag, then {@link FALLBACK_LOCALE}.
+ */
+export function getNativeLanguageName(code) {
+    return getLanguageMetadata(code)?.nativeName || code || FALLBACK_LOCALE;
+}
+/**
+ * Base language subtags whose scripts are written right-to-left. Used to drive
+ * `I18nManager.forceRTL(...)` on React Native and `<html dir="rtl">` on web.
+ * Includes Arabic (`ar`), Hebrew (`he` / legacy `iw`), Persian (`fa`), and
+ * Urdu (`ur`).
  */
 const RTL_LANGUAGE_BASES = new Set(['ar', 'he', 'iw', 'fa', 'ur']);
+/**
+ * Whether a locale (or bare base subtag) is written right-to-left. Unknown
+ * tags are treated as left-to-right.
+ */
 export function isRTLLocale(locale) {
     if (!locale)
         return false;
-    const base = locale.toLowerCase().split('-')[0];
-    if (!base)
-        return false;
-    return RTL_LANGUAGE_BASES.has(base);
+    return RTL_LANGUAGE_BASES.has(getBaseLanguage(locale));
+}
+/**
+ * Resolve the ordered list of account locales for a user, primary first.
+ *
+ * Reads `user.languages` (the only source — there is no singular `language`
+ * field), then normalizes each entry to its canonical `language-REGION` form,
+ * drops non-string and unsupported entries, and de-duplicates while preserving
+ * first-seen order. Pure and side-effect free — never throws on bad input.
+ */
+export function getUserLanguages(user) {
+    const source = user?.languages;
+    if (!Array.isArray(source))
+        return [];
+    const result = [];
+    const seen = new Set();
+    for (const entry of source) {
+        if (typeof entry !== 'string')
+            continue;
+        const canonical = normalizeLocale(entry);
+        if (!canonical || seen.has(canonical))
+            continue;
+        seen.add(canonical);
+        result.push(canonical);
+    }
+    return result;
+}
+/**
+ * Resolve the single PRIMARY locale for a user (the first entry from
+ * {@link getUserLanguages}), or `undefined` when the user has no supported
+ * locale.
+ */
+export function getPrimaryLanguage(user) {
+    return getUserLanguages(user)[0];
 }

package/dist/esm/utils/platform.js

@@ -5,6 +5,13 @@
  * This allows core modules to be used in web/Node.js environments
  * without bundlers failing on react-native imports.
  */
+/**
+ * Typed view over `globalThis` for the RN-platform marker, avoiding an `any`
+ * cast at each access site.
+ */
+function rnPlatformGlobal() {
+    return globalThis;
+}
 /**
  * Detect the current platform without importing react-native
  *
@@ -17,7 +24,7 @@
 function detectPlatform() {
     // Check if React Native Platform is available globally (set by RN runtime)
     // This avoids static imports while still detecting RN environment
-    const rnPlatform = globalThis.__REACT_NATIVE_PLATFORM__;
+    const rnPlatform = rnPlatformGlobal().__REACT_NATIVE_PLATFORM__;
     if (rnPlatform) {
         return rnPlatform;
     }
@@ -81,7 +88,7 @@ export function isAndroid() {
  */
 export function setPlatformOS(os) {
     cachedPlatform = os;
-    globalThis.__REACT_NATIVE_PLATFORM__ = os;
+    rnPlatformGlobal().__REACT_NATIVE_PLATFORM__ = os;
 }
 /**
  * True only in a real web browser (a DOM is present), false on React Native

package/dist/esm/utils/textNormalization.js

@@ -0,0 +1,164 @@
+/**
+ * Canonical text normalization for the Oxy ecosystem.
+ *
+ * WHY THIS EXISTS
+ * ---------------
+ * Third-party text (federated actor display names, spoiler/CW text, image alt
+ * text, bios, `<title>` / `og:site_name` of scraped remote pages, …) arrives
+ * with the whitespace the remote author's markup happened to contain. A real
+ * bug: a remote page served
+ *
+ *     <title>
+ *       Mi título
+ *     </title>
+ *
+ * and the extracted string — newlines and indentation included — was stored
+ * verbatim. Clients render text with React Native Web `Text`, which maps to
+ * CSS `white-space: pre-wrap`: unlike HTML, newlines and repeated spaces are
+ * NOT collapsed at render time, so the user saw a blank line and a six-space
+ * indent inside the link preview.
+ *
+ * Storage-time normalization is therefore the ONLY place this can be fixed:
+ * every renderer downstream is faithful by design.
+ *
+ * WHICH HELPER DO I USE?
+ * ----------------------
+ *  - {@link normalizeInlineText} — the value is conceptually ONE LINE, and a
+ *    line break in it is always an accident of the source markup: page titles,
+ *    `siteName`, display names, image `alt`, handles, profile field labels.
+ *    Every line break becomes a space.
+ *
+ *  - {@link normalizeMultilineText} — the value is a BODY whose line breaks are
+ *    the author's own paragraphs and must survive: post text, bios/summaries.
+ *    Line breaks are preserved (capped at one blank line); only the surrounding
+ *    whitespace noise is cleaned.
+ *
+ * Using the multiline helper on a title would keep the newlines and reproduce
+ * the original bug; using the inline helper on a post body would flatten the
+ * author's paragraphs into a single run-on line. Pick deliberately.
+ *
+ * Neither helper truncates, strips markup, or enforces a character policy —
+ * those are separate, product-specific concerns (see `isValidDisplayName` for
+ * the display-name character policy). These functions do exactly one thing:
+ * normalize whitespace and Unicode form.
+ */
+/**
+ * Characters that make a value ineligible for the zero-work fast path, and the
+ * whitespace shapes that a normalized INLINE value can never contain.
+ *
+ * A value that matches nothing here is, by construction, already normalized:
+ * it holds only printable ASCII (which is NFC-stable, so `normalize('NFC')`
+ * would be a no-op), its only whitespace is the plain space, it has no leading
+ * or trailing space, and no run of two spaces. Returning it untouched skips
+ * three string allocations — worth it because the common case in the feed
+ * hydration hot path is text that is already clean.
+ *
+ * Non-global (safe for repeated `.test()`; a global regex is stateful).
+ */
+const INLINE_NEEDS_NORMALIZATION = /[^\x20-\x7E]|^ | $| {2}/;
+/**
+ * Same idea as {@link INLINE_NEEDS_NORMALIZATION}, for MULTILINE values: `\n`
+ * joins the printable-ASCII fast-path alphabet, and the additional shapes a
+ * normalized body can never contain are a space before a line break (trailing
+ * horizontal whitespace) and a run of three line breaks (more than one blank
+ * line). A single space AFTER a line break is legal — a one-space indent is
+ * the author's, and normalization deliberately preserves it.
+ */
+const MULTILINE_NEEDS_NORMALIZATION = /[^\x20-\x7E\n]|^[ \n]|[ \n]$| {2}| \n|\n{3}/;
+/** Any run of whitespace, including tabs, line breaks and Unicode spaces. */
+const ANY_WHITESPACE_RUN = /\s+/g;
+/**
+ * Every line-break form, unified to `\n` before the multiline passes run:
+ * CRLF (Windows), a lone CR (classic Mac / stray `\r`), and the Unicode LINE
+ * SEPARATOR (U+2028) / PARAGRAPH SEPARATOR (U+2029), which are mandatory breaks
+ * in Unicode and a well-known hazard in JSON/JS payloads. CRLF must be matched
+ * before the lone `\r` alternative or it would yield two breaks. The separators
+ * are matched by Unicode property (`\p{Zl}` = U+2028, `\p{Zp}` = U+2029) rather
+ * than as literals: a literal U+2028/U+2029 is a LineTerminator and cannot appear
+ * inside a regex literal at all.
+ */
+const LINE_BREAK_FORMS = /\r\n|\r|\p{Zl}|\p{Zp}/gu;
+/**
+ * A run of HORIZONTAL whitespace: any whitespace that is not a line break.
+ * `[^\S\n]` is "whitespace, minus `\n`" — it covers the tab, the vertical tab,
+ * the form feed and every Unicode space separator (NBSP U+00A0, the U+2000
+ * block, the ideographic space U+3000, the zero-width no-break space U+FEFF).
+ * Applied AFTER {@link LINE_BREAK_FORMS}, so no line break can hide in it.
+ */
+const HORIZONTAL_WHITESPACE_RUN = /[^\S\n]+/g;
+/** Horizontal whitespace at the end of a line — the blank-line spoiler. */
+const TRAILING_HORIZONTAL_WHITESPACE = / +\n/g;
+/** Three or more line breaks: more than one blank line between paragraphs. */
+const EXCESS_BLANK_LINES = /\n{3,}/g;
+/**
+ * Normalize a SINGLE-LINE text value: page/link-preview titles, `siteName`,
+ * display names, image alt text, handles, profile field labels.
+ *
+ * A line break in such a value is never meaningful — it is an artifact of the
+ * markup the value was extracted from (`<title>\n  Título\n</title>`) — and it
+ * survives into the UI because RN Web renders `Text` with `white-space:
+ * pre-wrap`. So ALL whitespace, line breaks included, collapses to one space.
+ *
+ *   1. NFC-normalize, so visually identical strings store and compare
+ *      identically (a decomposed `e`+◌́ recomposes into `é`).
+ *   2. Collapse every run of whitespace — spaces, tabs, `\n`, `\r`, and Unicode
+ *      spaces such as NBSP — to a single plain space.
+ *   3. Trim both ends.
+ *
+ * Length is NOT capped: a maximum length is a product rule of the specific
+ * field (see `MAX_DISPLAY_NAME_LENGTH`), not a property of text normalization.
+ * Markup is NOT stripped: run the caller's sanitizer first if the source can
+ * contain HTML.
+ *
+ * A value that is empty or whitespace-only returns `''`. Callers decide whether
+ * that means "omit the field" (`|| undefined`) or "store an empty string".
+ *
+ * Idempotent: `f(f(x)) === f(x)`.
+ */
+export function normalizeInlineText(value) {
+    if (!INLINE_NEEDS_NORMALIZATION.test(value)) {
+        return value;
+    }
+    return value.normalize('NFC').replace(ANY_WHITESPACE_RUN, ' ').trim();
+}
+/**
+ * Normalize a MULTILINE text BODY: post text, bios, summaries — anywhere the
+ * line breaks are the author's paragraphs and must be preserved.
+ *
+ * Cleans the whitespace noise around those paragraphs without destroying them:
+ *
+ *   1. NFC-normalize (same rationale as {@link normalizeInlineText}).
+ *   2. Unify every line-break form (CRLF, lone CR, U+2028, U+2029) to `\n`.
+ *   3. Collapse runs of HORIZONTAL whitespace (spaces, tabs, NBSP and friends)
+ *      to a single space. Line breaks are untouched.
+ *   4. Strip the horizontal whitespace at the END of each line.
+ *   5. Collapse three or more line breaks to exactly one blank line (`\n\n`).
+ *   6. Trim both ends.
+ *
+ * STEP 4 MUST PRECEDE STEP 5 — this is the whole point of the function. A
+ * "blank" line that actually contains spaces (`"a\n   \n   \nb"`) breaks the
+ * run of `\n` characters, so a bare `\n{3,}` collapse (step 5 alone) never sees
+ * it and the extra blank lines survive into the UI. That is exactly the bug in
+ * federated post bodies. Removing the trailing horizontal whitespace first
+ * turns those lines into real, empty lines, which step 5 then collapses.
+ *
+ * A single space at the START of a line is preserved: only RUNS of horizontal
+ * whitespace collapse, and an indent is not trailing whitespace, so a one-space
+ * indent is treated as the author's and left alone.
+ *
+ * A value that is empty or whitespace-only returns `''`.
+ *
+ * Idempotent: `f(f(x)) === f(x)`.
+ */
+export function normalizeMultilineText(value) {
+    if (!MULTILINE_NEEDS_NORMALIZATION.test(value)) {
+        return value;
+    }
+    return value
+        .normalize('NFC')
+        .replace(LINE_BREAK_FORMS, '\n')
+        .replace(HORIZONTAL_WHITESPACE_RUN, ' ')
+        .replace(TRAILING_HORIZONTAL_WHITESPACE, '\n')
+        .replace(EXCESS_BLANK_LINES, '\n\n')
+        .trim();
+}