@oxy.so/services 13.6.0 → 13.8.0

package/src/ui/components/__tests__/LanguageBridge.test.tsx

@@ -1,91 +1,111 @@
 import React from 'react';
-import { render } from '@testing-library/react';
+import { act, render, waitFor } from '@testing-library/react';
 import { LanguageBridge } from '../LanguageBridge';
 
-/**
- * `OxyProvider`'s language config prop, realized: the one place Oxy's
- * resolved language reaches a host app's own i18n library. `useOxy` is mocked here —
- * it is the SDK's own well-tested context — so these tests exercise exactly
- * what this component adds: coercion to the caller's catalog, and calling
- * back only when the RESOLVED locale actually changes.
- */
-
 let mockCurrentLanguage = 'en-US';
+let mockLanguageReady = true;
+let mockAuthResolved = true;
 jest.mock('../../context/oxyRuntimeContext', () => ({
-  useOxy: () => ({ currentLanguage: mockCurrentLanguage }),
+  useOxy: () => ({
+    currentLanguage: mockCurrentLanguage,
+    isLanguageReady: mockLanguageReady,
+    isAuthResolved: mockAuthResolved,
+  }),
 }));
-
 const HOST_CATALOG = ['en-US', 'es-ES', 'fr-FR'] as const;
-
 beforeEach(() => {
   mockCurrentLanguage = 'en-US';
+  mockLanguageReady = true;
+  mockAuthResolved = true;
 });
 
-it('resolves and reports the account language on mount', () => {
-  mockCurrentLanguage = 'es-ES';
+it.each([
+  ['es-ES', 'es-ES'],
+  ['es-MX', 'es-ES'],
+  ['ja-JP', 'en-US'],
+])('resolves %s to the host catalog %s', async (locale, expected) => {
+  mockCurrentLanguage = locale;
   const onChange = jest.fn();
   render(
-    <LanguageBridge supportedLocales={HOST_CATALOG} fallbackLocale="en-US" onChange={onChange} />,
+    <LanguageBridge config={{ supportedLocales: HOST_CATALOG, fallbackLocale: 'en-US', onChange }}>
+      <span>App</span>
+    </LanguageBridge>,
   );
-
-  expect(onChange).toHaveBeenCalledWith('es-ES');
+  await waitFor(() => expect(onChange).toHaveBeenCalledWith(expected));
 });
 
-it('coerces a locale the host never shipped a catalog for, by base language', () => {
-  mockCurrentLanguage = 'es-MX';
-  const onChange = jest.fn();
-  render(
-    <LanguageBridge supportedLocales={HOST_CATALOG} fallbackLocale="en-US" onChange={onChange} />,
+it('does not paint any app text before saved preferences, account restoration and catalog loading finish', async () => {
+  mockLanguageReady = false;
+  mockAuthResolved = false;
+  let finishCatalog: (() => void) | undefined;
+  const onChange = jest.fn(
+    () =>
+      new Promise<void>((resolve) => {
+        finishCatalog = resolve;
+      }),
   );
-
-  expect(onChange).toHaveBeenCalledWith('es-ES');
-});
-
-it('falls back to the caller default when nothing matches, even by base', () => {
-  mockCurrentLanguage = 'ja-JP';
-  const onChange = jest.fn();
-  render(
-    <LanguageBridge supportedLocales={HOST_CATALOG} fallbackLocale="en-US" onChange={onChange} />,
-  );
-
-  expect(onChange).toHaveBeenCalledWith('en-US');
+  const config = { supportedLocales: HOST_CATALOG, fallbackLocale: 'en-US', onChange };
+  const children = <span>Translated app</span>;
+  const screen = render(<LanguageBridge config={config}>{children}</LanguageBridge>);
+  expect(screen.queryByText('Translated app')).toBeNull();
+  expect(onChange).not.toHaveBeenCalled();
+  mockLanguageReady = true;
+  mockCurrentLanguage = 'es-ES';
+  screen.rerender(<LanguageBridge config={config}>{children}</LanguageBridge>);
+  expect(onChange).not.toHaveBeenCalled();
+  mockAuthResolved = true;
+  screen.rerender(<LanguageBridge config={config}>{children}</LanguageBridge>);
+  await waitFor(() => expect(onChange).toHaveBeenCalledWith('es-ES'));
+  expect(screen.queryByText('Translated app')).toBeNull();
+  await act(async () => finishCatalog?.());
+  expect(screen.getByText('Translated app')).toBeTruthy();
 });
 
-it('calls back again only when the RESOLVED locale changes', () => {
+it('keeps route state mounted across a language change and ignores callback identity changes', async () => {
+  let mounts = 0;
+  function Page() {
+    React.useEffect(() => {
+      mounts += 1;
+    }, []);
+    return <span>App</span>;
+  }
   const onChange = jest.fn();
-  const { rerender } = render(
-    <LanguageBridge supportedLocales={HOST_CATALOG} fallbackLocale="en-US" onChange={onChange} />,
+  const config = { supportedLocales: HOST_CATALOG, fallbackLocale: 'en-US', onChange };
+  const screen = render(
+    <LanguageBridge config={config}>
+      <Page />
+    </LanguageBridge>,
   );
-  expect(onChange).toHaveBeenCalledTimes(1);
-
-  // Same resolved locale, brand-new callback identity (the common case for an
-  // inline arrow function) — must not re-fire.
-  rerender(
-    <LanguageBridge supportedLocales={HOST_CATALOG} fallbackLocale="en-US" onChange={() => {}} />,
+  await waitFor(() => expect(mounts).toBe(1));
+  screen.rerender(
+    <LanguageBridge config={{ ...config, onChange: jest.fn() }}>
+      <Page />
+    </LanguageBridge>,
   );
   expect(onChange).toHaveBeenCalledTimes(1);
-
   mockCurrentLanguage = 'fr-FR';
-  rerender(
-    <LanguageBridge supportedLocales={HOST_CATALOG} fallbackLocale="en-US" onChange={onChange} />,
+  screen.rerender(
+    <LanguageBridge config={config}>
+      <Page />
+    </LanguageBridge>,
   );
-  expect(onChange).toHaveBeenCalledTimes(2);
-  expect(onChange).toHaveBeenLastCalledWith('fr-FR');
+  await waitFor(() => expect(onChange).toHaveBeenLastCalledWith('fr-FR'));
+  expect(mounts).toBe(1);
 });
 
-it('reports a rejected onChange to onError instead of throwing', async () => {
-  const failure = new Error('catalog failed to load');
-  const onChange = jest.fn().mockRejectedValue(failure);
+it('reports a failed catalog and initializes the fallback before showing children', async () => {
+  mockCurrentLanguage = 'es-ES';
+  const failure = new Error('catalog unavailable');
+  const onChange = jest.fn().mockRejectedValueOnce(failure).mockResolvedValueOnce(undefined);
   const onError = jest.fn();
-  render(
+  const screen = render(
     <LanguageBridge
-      supportedLocales={HOST_CATALOG}
-      fallbackLocale="en-US"
-      onChange={onChange}
-      onError={onError}
-    />,
+      config={{ supportedLocales: HOST_CATALOG, fallbackLocale: 'en-US', onChange, onError }}
+    >
+      <span>App</span>
+    </LanguageBridge>,
   );
-
-  await new Promise((resolve) => setTimeout(resolve, 0));
-  expect(onError).toHaveBeenCalledWith(failure, 'en-US');
+  await waitFor(() => expect(screen.getByText('App')).toBeTruthy());
+  expect(onError).toHaveBeenCalledWith(failure, 'es-ES');
+  expect(onChange.mock.calls.map(([locale]) => locale)).toEqual(['es-ES', 'en-US']);
 });

package/src/ui/components/signIn/OxySignUpPanel.tsx

@@ -67,7 +67,13 @@ export const OxySignUpPanel: React.FC<OxySignUpPanelProps> = ({
   host = 'page',
 }) => {
   const { t } = useI18n();
-  const { oxyServices, handleWebSession, accountDialogController } = useOxy();
+  const {
+    oxyServices,
+    handleWebSession,
+    accountDialogController,
+    currentLanguage,
+    campaignAttribution,
+  } = useOxy();
   const snapshot = useAccountDialogSnapshot(accountDialogController);
   const flowOwner = host === 'dialog' ? accountDialogController : null;
   const [saved] = useState(() => readSignInFlow<SavedSignUpFlow>(flowOwner, SIGN_UP_FLOW_KEY));
@@ -139,6 +145,8 @@ export const OxySignUpPanel: React.FC<OxySignUpPanelProps> = ({
         username: username.trim(),
         email,
         emailTicket: ticket,
+        languages: [currentLanguage],
+        ...(campaignAttribution ? { campaignAttribution } : {}),
       });
       await handleWebSession(session);
       writeSignInFlow(flowOwner, SIGN_UP_FLOW_KEY, undefined);

package/src/ui/context/OxyContext.tsx

@@ -1,3 +1,4 @@
+import { installNativeAssetFiles } from '../utils/nativeAssetFiles';
 import {
   startNativeOAuthSignIn,
   type StartNativeOAuthSignInOptions,
@@ -9,7 +10,15 @@ import {
   setIsolatedOAuthSession,
 } from './isolatedOAuthSession';
 import type React from 'react';
-import { useCallback, useEffect, useMemo, useRef, useState, useSyncExternalStore } from 'react';
+import {
+  useCallback,
+  useEffect,
+  useLayoutEffect,
+  useMemo,
+  useRef,
+  useState,
+  useSyncExternalStore,
+} from 'react';
 import { AppState, Linking, Platform } from 'react-native';
 import { OxyServices } from '@oxy.so/core';
 import type { LoginSessionResult } from '@oxy.so/contracts';
@@ -62,6 +71,7 @@ import {
 import { createTokenLossRecovery, TOKEN_RECOVERY_BACKOFF_MS } from '../session/tokenLossRecovery';
 import { createCachedBootStore, type CachedBootStore } from '../session/cachedBoot';
 import { bindAuthStoreToRuntime } from '../stores/authStore';
+import { useEntryLink } from '../hooks/useEntryLink';
 import { useLanguageManagement } from '../hooks/useLanguageManagement';
 import { useSessionManagement } from '../hooks/useSessionManagement';
 import { useAuthOperations, clearPersistedAuthSafe } from './hooks/useAuthOperations';
@@ -153,6 +163,8 @@ export const OxyRuntimeProvider: React.FC<OxyRuntimeProviderProps> = ({
   sessionMode = 'account',
   webAuthMode = 'popup',
   backgroundSession = false,
+  legacyLanguageKeys,
+  captureCampaignAttribution = false,
   platformStorage,
   accountQueries,
   onAuthStateChange,
@@ -179,6 +191,9 @@ export const OxyRuntimeProvider: React.FC<OxyRuntimeProviderProps> = ({
     }
   }
   const oxyServices = oxyServicesRef.current;
+  // Child passive effects may upload immediately on mount. Configure transport
+  // during commit, before those effects, without mutating the client in render.
+  useLayoutEffect(() => installNativeAssetFiles(oxyServices), [oxyServices]);
 
   // The device-first persisted auth-state store (per-origin device credential on
   // web; SecureStore session blob on native). Built ONCE per provider mount.
@@ -415,8 +430,10 @@ export const OxyRuntimeProvider: React.FC<OxyRuntimeProviderProps> = ({
       .catch((err) => {
         // Nothing persisted can be restored; the account cache still has to
         // become ready, or RequireOxyAuth would wait forever.
-        accountQueryPersistence.setStorage(createMemoryStorage());
+        const memoryStorage = createMemoryStorage();
+        accountQueryPersistence.setStorage(memoryStorage);
         if (mounted) {
+          setStorage(memoryStorage);
           logger('Failed to initialize storage', err);
           onError?.({
             message: 'Failed to initialize storage',
@@ -430,8 +447,15 @@ export const OxyRuntimeProvider: React.FC<OxyRuntimeProviderProps> = ({
     };
   }, [accountQueryPersistence, logger, onError, platformStorage, runtime, storageReady]);
 
+  const entryLink = useEntryLink({
+    storage,
+    storageKey: `${storageKeyPrefix}_campaign_attribution`,
+    captureCampaign: captureCampaignAttribution,
+    onError: logger,
+  });
   const {
     currentLanguage,
+    isLanguageReady,
     languages: currentLanguages,
     metadata: currentLanguageMetadata,
     languageName: currentLanguageName,
@@ -441,6 +465,9 @@ export const OxyRuntimeProvider: React.FC<OxyRuntimeProviderProps> = ({
   } = useLanguageManagement({
     storage,
     languageKey: storageKeys.language,
+    entryUrl: entryLink.url,
+    entryLinkReady: entryLink.ready,
+    legacyLanguageKeys,
     user,
     onError,
     logger,
@@ -1751,6 +1778,8 @@ export const OxyRuntimeProvider: React.FC<OxyRuntimeProviderProps> = ({
       webAuthMode,
       error,
       currentLanguage,
+      isLanguageReady: isLanguageReady && entryLink.campaignReady,
+      campaignAttribution: entryLink.campaignAttribution,
       currentLanguages,
       currentLanguageMetadata,
       currentLanguageName,
@@ -1808,6 +1837,9 @@ export const OxyRuntimeProvider: React.FC<OxyRuntimeProviderProps> = ({
       webAuthMode,
       error,
       currentLanguage,
+      isLanguageReady,
+      entryLink.campaignReady,
+      entryLink.campaignAttribution,
       currentLanguages,
       currentLanguageMetadata,
       currentLanguageName,

package/src/ui/context/oxyContextTypes.ts

@@ -1,3 +1,4 @@
+import type { CampaignAttribution } from '@oxy.so/contracts';
 import type {
   StartNativeOAuthSignInOptions,
   NativeOAuthSignInResult,
@@ -85,6 +86,8 @@ export interface OxyContextState {
   error: string | null;
   /** Active UI locale (`language-REGION`): the account's primary locale when signed in, else the guest/device locale. */
   currentLanguage: string;
+  isLanguageReady: boolean;
+  campaignAttribution?: CampaignAttribution;
   /** Ordered account locales (primary first) when signed in, or the single guest override when signed out. */
   currentLanguages: string[];
   currentLanguageMetadata: ReturnType<typeof useLanguageManagement>['metadata'];
@@ -180,6 +183,8 @@ export interface OxyContextState {
 }
 
 export interface OxyRuntimeProviderProps {
+  legacyLanguageKeys?: readonly string[];
+  captureCampaignAttribution?: boolean;
   children: ReactNode;
   oxyServices?: OxyServices;
   baseURL?: string;

package/src/ui/hooks/useEntryLink.ts

@@ -0,0 +1,103 @@
+import { useEffect, useRef, useState } from 'react';
+import { Linking, Platform } from 'react-native';
+import type { CampaignAttribution } from '@oxy.so/contracts';
+import type { StorageInterface } from '../utils/storageHelpers';
+import { readCampaignAttribution, readEntryLink } from '../utils/entryLink';
+
+/** One receiver for initial and warm native links and web entry parameters. */
+export function useEntryLink({
+  storage,
+  storageKey,
+  captureCampaign,
+  onError,
+}: {
+  storage: StorageInterface | null;
+  storageKey: string;
+  captureCampaign: boolean;
+  onError: (message: string, error?: unknown) => void;
+}) {
+  const [entry, setEntry] = useState<{
+    url: string | null | undefined;
+    ready: boolean;
+    firstCampaign?: CampaignAttribution;
+  }>({ url: undefined, ready: false });
+  const [campaignAttribution, setCampaignAttribution] = useState<CampaignAttribution>();
+  const [campaignReady, setCampaignReady] = useState(false);
+  const captures = useRef(Promise.resolve());
+
+  useEffect(() => {
+    let active = true;
+    const subscription = Linking.addEventListener('url', ({ url }) => {
+      setEntry((current) => ({
+        ...current,
+        url,
+        firstCampaign: current.firstCampaign ?? readEntryLink(url).campaignAttribution,
+      }));
+    });
+    const initialUrl =
+      Platform.OS === 'web' && typeof window !== 'undefined'
+        ? Promise.resolve(window.location.href)
+        : Linking.getInitialURL();
+    initialUrl
+      .then((initial) => {
+        if (active)
+          setEntry((current) => ({
+            url: current.url === undefined ? initial : current.url,
+            ready: true,
+            firstCampaign:
+              readEntryLink(initial ?? null).campaignAttribution ?? current.firstCampaign,
+          }));
+      })
+      .catch((error: unknown) => {
+        onError('Failed to read the initial entry link', error);
+        if (active) setEntry((current) => ({ ...current, url: current.url ?? null, ready: true }));
+      });
+    return () => {
+      active = false;
+      subscription.remove();
+    };
+  }, [onError]);
+
+  useEffect(() => {
+    if (!storage || !entry.ready) return;
+    let active = true;
+    async function capture() {
+      if (!captureCampaign) {
+        if (active) setCampaignReady(true);
+        return;
+      }
+      let stored: CampaignAttribution | undefined;
+      const raw = await storage?.getItem(storageKey);
+      if (raw) {
+        try {
+          stored = readCampaignAttribution(JSON.parse(raw));
+        } catch {
+          onError('Stored campaign attribution is malformed');
+        }
+      }
+      const selected = stored ?? entry.firstCampaign;
+      if (selected && !stored) await storage?.setItem(storageKey, JSON.stringify(selected));
+      if (active) {
+        setCampaignAttribution(selected);
+        setCampaignReady(true);
+      }
+    }
+    captures.current = captures.current.then(capture).catch((error: unknown) => {
+      onError('Failed to persist campaign attribution', error);
+      if (active) {
+        setCampaignAttribution(entry.firstCampaign);
+        setCampaignReady(true);
+      }
+    });
+    return () => {
+      active = false;
+    };
+  }, [captureCampaign, entry.ready, entry.firstCampaign, onError, storage, storageKey]);
+
+  return {
+    url: entry.url,
+    ready: entry.ready,
+    campaignAttribution,
+    campaignReady: !captureCampaign || campaignReady,
+  };
+}

package/src/ui/hooks/useLanguageManagement.ts

@@ -12,11 +12,15 @@ import {
   normalizeLocale,
 } from '@oxy.so/core';
 import type { StorageInterface } from '../utils/storageHelpers';
+import { readEntryLink } from '../utils/entryLink';
 import { extractErrorMessage } from '../utils/errorHandlers';
 
 export interface UseLanguageManagementOptions {
   storage: StorageInterface | null;
   languageKey: string;
+  entryUrl?: string | null;
+  entryLinkReady?: boolean;
+  legacyLanguageKeys?: readonly string[];
   /**
    * The active account, when signed in. When present, the account's primary
    * locale (`languages[0]`) is authoritative for the app's UI locale; when
@@ -34,6 +38,7 @@ export interface UseLanguageManagementResult {
    * locally-chosen guest override, otherwise the device locale.
    */
   currentLanguage: string;
+  isLanguageReady: boolean;
   /**
    * The ordered account locales (primary first) when signed in, or the locally
    * persisted selection when signed out. Empty only before the guest override loads
@@ -145,6 +150,9 @@ function resolveDeviceLocale(): string {
 export const useLanguageManagement = ({
   storage,
   languageKey,
+  entryUrl = null,
+  entryLinkReady = true,
+  legacyLanguageKeys,
   user,
   onError,
   logger,
@@ -156,6 +164,8 @@ export const useLanguageManagement = ({
   // Until it loads, the UI uses the device locale.
   const [guestLanguages, setGuestLanguages] = useState<string[]>([]);
   const selectionVersion = useRef(0);
+  const [isLanguageReady, setLanguageReady] = useState(false);
+  const legacyKeysSignature = JSON.stringify(legacyLanguageKeys ?? []);
 
   const loadLanguageFromStorage = useCallback(async (): Promise<void> => {
     if (!storage) {
@@ -164,24 +174,45 @@ export const useLanguageManagement = ({
 
     const version = selectionVersion.current;
     try {
-      const savedLanguageRaw = await storage.getItem(languageKey);
-      // Migrate the former single locale without discarding existing preferences.
-      let stored: unknown = savedLanguageRaw;
-      if (savedLanguageRaw?.startsWith('[')) {
-        stored = JSON.parse(savedLanguageRaw);
+      function parseStored(raw: string | null): string[] {
+        let stored: unknown = raw;
+        if (raw?.startsWith('[') || raw?.startsWith('"')) {
+          try {
+            stored = JSON.parse(raw);
+          } catch {
+            return [];
+          }
+        }
+        const entries = Array.isArray(stored) ? stored : [stored];
+        return [
+          ...new Set(
+            entries.flatMap((entry) => {
+              const locale = typeof entry === 'string' ? normalizeLocale(entry) : undefined;
+              return locale ? [locale] : [];
+            }),
+          ),
+        ];
       }
-      const entries = Array.isArray(stored) ? stored : [stored];
-      const normalized = [
-        ...new Set(
-          entries.flatMap((entry) => {
-            const locale = typeof entry === 'string' ? normalizeLocale(entry) : undefined;
-            return locale ? [locale] : [];
-          }),
-        ),
-      ];
-      if (normalized.length && version === selectionVersion.current) {
-        setGuestLanguages(normalized);
+      let normalized = parseStored(await storage.getItem(languageKey));
+      let migratedKey: string | undefined;
+      const legacyKeys: string[] = JSON.parse(legacyKeysSignature);
+      if (!normalized.length) {
+        for (const key of legacyKeys) {
+          normalized = parseStored(await storage.getItem(key));
+          if (normalized.length) {
+            migratedKey = key;
+            break;
+          }
+        }
+      }
+      const linkedLanguage = readEntryLink(entryUrl).language;
+      const selected = linkedLanguage ? [linkedLanguage] : normalized;
+      if (version !== selectionVersion.current) return;
+      if (linkedLanguage || migratedKey) {
+        await storage.setItem(languageKey, JSON.stringify(selected));
+        if (migratedKey) await storage.removeItem(migratedKey);
       }
+      if (selected.length && version === selectionVersion.current) setGuestLanguages(selected);
     } catch (error) {
       const message = extractErrorMessage(error, 'Failed to load language preference');
       onError?.({
@@ -194,16 +225,19 @@ export const useLanguageManagement = ({
       } else if (__DEV__) {
         console.warn('Failed to load language preference:', error);
       }
+    } finally {
+      setLanguageReady(true);
     }
-  }, [languageKey, logger, onError, storage]);
+  }, [entryUrl, languageKey, legacyKeysSignature, logger, onError, storage]);
 
   useEffect(() => {
+    if (!entryLinkReady) return;
     loadLanguageFromStorage().catch((error) => {
       if (logger) {
         logger('Unexpected error loading language', error);
       }
     });
-  }, [loadLanguageFromStorage, logger]);
+  }, [entryLinkReady, loadLanguageFromStorage, logger]);
 
   const setLanguages = useCallback(
     async (locales: readonly string[]): Promise<void> => {
@@ -268,6 +302,7 @@ export const useLanguageManagement = ({
 
   return {
     currentLanguage,
+    isLanguageReady,
     languages,
     metadata,
     languageName,

package/src/ui/types/navigation.ts

@@ -182,9 +182,13 @@ export interface OxyProviderProps {
    * manages it independently of the account/device locale.
    */
   language?: OxyLanguageConfig;
+  /** Persist bounded first-touch link labels and attach them only to a new account. */
+  campaignAttribution?: boolean;
 }
 
 export interface OxyLanguageConfig {
+  /** Previous app-owned storage keys, migrated once without replacing a current SDK choice. */
+  legacyStorageKeys?: readonly string[];
   /** The exact locales this app ships a translation catalog for. */
   supportedLocales: readonly string[];
   /**

package/src/ui/utils/__tests__/entryLink.test.ts

@@ -0,0 +1,30 @@
+import { readEntryLink, readCampaignAttribution } from '../entryLink';
+
+it.each([
+  ['https://mention.earth/?lang=es', 'es-ES'],
+  ['mention://compose?lang=fr-BE', 'fr-FR'],
+  ['https://mention.earth/?lang=zz', undefined],
+  ['https://mention.earth/?lang=en&lang=es', undefined],
+  ['not a url', undefined],
+])('resolves supported entry locale %s', (url, expected) => {
+  expect(readEntryLink(url).language).toBe(expected);
+});
+
+it('captures only campaign fields without retaining the URL, a referrer or unrelated private query data', () => {
+  expect(
+    readEntryLink(
+      'https://mention.earth/write?utm_source=meta&utm_campaign=Spain&fbclid=click&email=private@example.test',
+    ),
+  ).toEqual({
+    language: undefined,
+    campaignAttribution: { utmSource: 'meta', utmCampaign: 'Spain', fbclid: 'click' },
+  });
+});
+
+it('drops empty, duplicate, overlong and control-character campaign values', () => {
+  const url = `mention://?utm_source=one&utm_source=two&utm_medium=&utm_campaign=${'x'.repeat(257)}&utm_content=bad%00value`;
+  expect(readEntryLink(url).campaignAttribution).toBeUndefined();
+  expect(
+    readCampaignAttribution({ fbclid: 'x'.repeat(1025), utmSource: ' meta ', private: 'secret' }),
+  ).toEqual({ utmSource: 'meta' });
+});