@stacksee/analytics 0.4.6 → 0.5.0

package/dist/adapters/client/browser-analytics.d.ts

@@ -1,10 +1,11 @@
 import { AnalyticsConfig, EventContext } from '../../core/events/types.js';
 type DefaultEventMap = Record<string, Record<string, unknown>>;
-export declare class BrowserAnalytics<TEventMap extends DefaultEventMap = DefaultEventMap> {
+export declare class BrowserAnalytics<TEventMap extends DefaultEventMap = DefaultEventMap, TUserTraits extends Record<string, unknown> = Record<string, unknown>> {
     private providers;
     private context;
     private userId?;
     private sessionId?;
+    private userTraits?;
     private initialized;
     private initializePromise?;
     /**
@@ -78,11 +79,16 @@ export declare class BrowserAnalytics<TEventMap extends DefaultEventMap = Defaul
      * sets user properties. This method should be called when a user logs in
      * or when you want to associate events with a known user.
      *
+     * **User Context (New):** User data (userId, email, traits) is automatically stored
+     * and included in all subsequent `track()` calls. This makes it easy for providers
+     * like Loops, Customer.io, or Intercom to access user information without passing
+     * it manually each time. The data is cleared when `reset()` is called (e.g., on logout).
+     *
      * The method automatically ensures initialization but doesn't block execution
      * if initialization is still in progress.
      *
      * @param userId Unique identifier for the user (e.g., database ID, email)
-     * @param traits Optional user properties and characteristics
+     * @param traits Optional user properties and characteristics (email, name, plan, etc.)
      *
      * @example
      * ```typescript
@@ -92,7 +98,7 @@ export declare class BrowserAnalytics<TEventMap extends DefaultEventMap = Defaul
      *
      * @example
      * ```typescript
-     * // Identify with user traits
+     * // Identify with user traits (recommended - enables email-based providers)
      * analytics.identify('user-123', {
      *   email: 'john@example.com',
      *   name: 'John Doe',
@@ -103,6 +109,10 @@ export declare class BrowserAnalytics<TEventMap extends DefaultEventMap = Defaul
      *     notifications: false
      *   }
      * });
+     *
+     * // Now all subsequent track() calls automatically include user context
+     * analytics.track('button_clicked', { buttonId: 'checkout' });
+     * // Providers receive: context.user = { userId: 'user-123', email: 'john@example.com', traits: {...} }
      * ```
      *
      * @example
@@ -111,15 +121,25 @@ export declare class BrowserAnalytics<TEventMap extends DefaultEventMap = Defaul
      * async function handleLogin(email: string, password: string) {
      *   const user = await login(email, password);
      *
+     *   // Identify user with full traits
      *   analytics.identify(user.id, {
      *     email: user.email,
      *     name: user.name,
+     *     plan: user.plan,
+     *     company: user.company,
      *     lastLogin: new Date().toISOString()
      *   });
+     *
+     *   // All subsequent events now include this user context automatically
+     * }
+     *
+     * // In a logout handler - clear user context
+     * async function handleLogout() {
+     *   analytics.reset(); // Clears userId and traits
      * }
      * ```
      */
-    identify(userId: string, traits?: Record<string, unknown>): void;
+    identify(userId: string, traits?: TUserTraits): void;
     /**
      * Tracks a custom event with properties.
      *
@@ -128,6 +148,10 @@ export declare class BrowserAnalytics<TEventMap extends DefaultEventMap = Defaul
      * configured providers. Events are enriched with context information like
      * timestamp, user ID, session ID, and browser context.
      *
+     * **User Context (New):** If `identify()` was called previously, user data (userId,
+     * email, traits) is automatically included in the event context sent to all providers.
+     * This happens transparently - you don't need to pass user data manually.
+     *
      * If providers are configured, the method waits for all providers to complete
      * tracking. Failed providers don't prevent others from succeeding.
      *
@@ -146,6 +170,19 @@ export declare class BrowserAnalytics<TEventMap extends DefaultEventMap = Defaul
      *
      * @example
      * ```typescript
+     * // User context is automatically included after identify()
+     * analytics.identify('user-123', {
+     *   email: 'user@example.com',
+     *   plan: 'pro'
+     * });
+     *
+     * // Now all events automatically include user context
+     * analytics.track('button_clicked', { buttonId: 'checkout' });
+     * // Providers receive: context.user = { userId: 'user-123', email: 'user@example.com', traits: {...} }
+     * ```
+     *
+     * @example
+     * ```typescript
      * // Track a purchase event
      * await analytics.track('purchase_completed', {
      *   orderId: 'order-123',
@@ -409,7 +446,7 @@ export declare class BrowserAnalytics<TEventMap extends DefaultEventMap = Defaul
      * });
      * ```
      */
-    updateContext(context: Partial<EventContext>): void;
+    updateContext(context: Partial<EventContext<TUserTraits>>): void;
     private getCategoryFromEventName;
     private generateSessionId;
     private getDeviceType;

package/dist/adapters/server/server-analytics.d.ts

@@ -1,6 +1,6 @@
-import { AnalyticsConfig, EventContext } from '../../core/events/types.js';
+import { AnalyticsConfig, EventContext, UserContext } from '../../core/events/types.js';
 type DefaultEventMap = Record<string, Record<string, unknown>>;
-export declare class ServerAnalytics<TEventMap extends Record<string, Record<string, unknown>> = DefaultEventMap> {
+export declare class ServerAnalytics<TEventMap extends Record<string, Record<string, unknown>> = DefaultEventMap, TUserTraits extends Record<string, unknown> = Record<string, unknown>> {
     private providers;
     private config;
     private initialized;
@@ -129,12 +129,17 @@ export declare class ServerAnalytics<TEventMap extends Record<string, Record<str
      * Server-side tracking typically includes additional context like IP addresses,
      * user agents, and server-specific metadata that isn't available on the client.
      *
+     * **User Context (New):** You can now pass user data (email, traits) with each event
+     * via `options.user` or `options.context.user`. This is useful for providers like
+     * Loops, Customer.io, or Intercom that require user identifiers.
+     *
      * @param eventName Name of the event to track (must match your event definitions)
      * @param properties Event-specific properties and data
-     * @param options Optional configuration including user ID, session ID, and context
+     * @param options Optional configuration including user ID, session ID, user context, and additional context
      * @param options.userId User ID to associate with this event
      * @param options.sessionId Session ID to associate with this event
-     * @param options.context Additional context for this event
+     * @param options.user User context including email and traits (automatically included in event context)
+     * @param options.context Additional context for this event (page, device, etc.)
      * @returns Promise that resolves when tracking is complete for all providers
      *
      * @example
@@ -150,7 +155,7 @@ export declare class ServerAnalytics<TEventMap extends Record<string, Record<str
      *
      * @example
      * ```typescript
-     * // Track with user context
+     * // Track with user context (recommended for email-based providers)
      * await analytics.track('purchase_completed', {
      *   orderId: 'order-123',
      *   amount: 99.99,
@@ -158,33 +163,61 @@ export declare class ServerAnalytics<TEventMap extends Record<string, Record<str
      *   itemCount: 3
      * }, {
      *   userId: 'user-456',
-     *   sessionId: 'session-789',
+     *   user: {
+     *     email: 'user@example.com',
+     *     traits: {
+     *       plan: 'pro',
+     *       company: 'Acme Corp'
+     *     }
+     *   },
      *   context: {
      *     page: { path: '/checkout/complete' },
-     *     device: { userAgent: req.headers['user-agent'] },
-     *     ip: req.ip
+     *     device: { userAgent: req.headers['user-agent'] }
      *   }
      * });
+     * // Providers receive: context.user = { email: 'user@example.com', traits: {...} }
      * ```
      *
      * @example
      * ```typescript
-     * // In an Express.js route handler
+     * // Alternative: Pass user via context.user
+     * await analytics.track('feature_used', {
+     *   featureName: 'export'
+     * }, {
+     *   userId: 'user-123',
+     *   context: {
+     *     user: {
+     *       email: 'user@example.com'
+     *     },
+     *     page: { path: '/dashboard' }
+     *   }
+     * });
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // In an Express.js route handler with user data
      * app.post('/api/users', async (req, res) => {
      *   const user = await createUser(req.body);
      *
-     *   // Track user creation with server context
+     *   // Track user creation with full user context
      *   await analytics.track('user_created', {
      *     userId: user.id,
      *     email: user.email,
      *     plan: user.plan
      *   }, {
      *     userId: user.id,
+     *     user: {
+     *       email: user.email,
+     *       traits: {
+     *         name: user.name,
+     *         plan: user.plan,
+     *         company: user.company
+     *       }
+     *     },
      *     context: {
      *       page: { path: req.path },
-     *       device: { userAgent: req.headers['user-agent'] },
-     *       ip: req.ip,
-     *       server: { version: process.env.APP_VERSION }
+     *       device: { userAgent: req.headers['user-agent'] }
      *     }
      *   });
      *
@@ -210,7 +243,8 @@ export declare class ServerAnalytics<TEventMap extends Record<string, Record<str
     track<TEventName extends string>(eventName: TEventName, properties: TEventName extends keyof TEventMap ? TEventMap[TEventName] : Record<string, unknown>, options?: {
         userId?: string;
         sessionId?: string;
-        context?: EventContext;
+        context?: EventContext<TUserTraits>;
+        user?: UserContext<TUserTraits>;
     }): Promise<void>;
     /**
      * Tracks a page view event from the server side.
@@ -273,7 +307,7 @@ export declare class ServerAnalytics<TEventMap extends Record<string, Record<str
      * ```
      */
     pageView(properties?: Record<string, unknown>, options?: {
-        context?: EventContext;
+        context?: EventContext<TUserTraits>;
     }): void;
     /**
      * Tracks when a user leaves a page from the server side.
@@ -335,7 +369,7 @@ export declare class ServerAnalytics<TEventMap extends Record<string, Record<str
      * ```
      */
     pageLeave(properties?: Record<string, unknown>, options?: {
-        context?: EventContext;
+        context?: EventContext<TUserTraits>;
     }): void;
     /**
      * Shuts down all analytics providers and flushes pending events.

package/dist/client-DTHZYkxx.js

@@ -0,0 +1,90 @@
+var o = Object.defineProperty;
+var d = (a, e, s) => e in a ? o(a, e, { enumerable: !0, configurable: !0, writable: !0, value: s }) : a[e] = s;
+var g = (a, e, s) => d(a, typeof e != "symbol" ? e + "" : e, s);
+import { B as l } from "./base.provider-AfFL5W_P.js";
+function t() {
+  return typeof window < "u" && typeof window.document < "u";
+}
+class n extends l {
+  constructor(s) {
+    super({ debug: s.debug, enabled: s.enabled });
+    g(this, "name", "PostHog-Client");
+    g(this, "posthog");
+    g(this, "initialized", !1);
+    g(this, "config");
+    this.config = s;
+  }
+  async initialize() {
+    if (this.isEnabled() && !this.initialized) {
+      if (!t()) {
+        this.log("Skipping initialization - not in browser environment");
+        return;
+      }
+      if (!this.config.token || typeof this.config.token != "string")
+        throw new Error("PostHog requires a token");
+      try {
+        const { default: s } = await import("posthog-js"), { token: i, debug: r, ...h } = this.config;
+        s.init(i, {
+          ...h,
+          debug: r ?? this.debug
+        }), this.posthog = s, this.initialized = !0, this.log("Initialized successfully", this.config);
+      } catch (s) {
+        throw console.error("[PostHog-Client] Failed to initialize:", s), s;
+      }
+    }
+  }
+  identify(s, i) {
+    !this.isEnabled() || !this.initialized || !this.posthog || (this.posthog.identify(s, i), this.log("Identified user", { userId: s, traits: i }));
+  }
+  track(s, i) {
+    var h, p;
+    if (!this.isEnabled() || !this.initialized || !this.posthog) return;
+    const r = {
+      ...s.properties,
+      category: s.category,
+      timestamp: s.timestamp || Date.now(),
+      ...s.userId && { userId: s.userId },
+      ...s.sessionId && { sessionId: s.sessionId },
+      ...(i == null ? void 0 : i.page) && { $current_url: i.page.path },
+      ...(i == null ? void 0 : i.device) && { device: i.device },
+      ...(i == null ? void 0 : i.utm) && { utm: i.utm },
+      // Include user email and traits as regular event properties
+      ...((h = i == null ? void 0 : i.user) == null ? void 0 : h.email) && { user_email: i.user.email },
+      ...((p = i == null ? void 0 : i.user) == null ? void 0 : p.traits) && { user_traits: i.user.traits }
+    };
+    this.posthog.capture(s.action, r), this.log("Tracked event", { event: s, context: i });
+  }
+  pageView(s, i) {
+    if (!this.isEnabled() || !this.initialized || !this.posthog || !t())
+      return;
+    const r = {
+      ...s,
+      ...(i == null ? void 0 : i.page) && {
+        path: i.page.path,
+        title: i.page.title,
+        referrer: i.page.referrer
+      }
+    };
+    this.posthog.capture("$pageview", r), this.log("Tracked page view", { properties: s, context: i });
+  }
+  pageLeave(s, i) {
+    if (!this.isEnabled() || !this.initialized || !this.posthog || !t())
+      return;
+    const r = {
+      ...s,
+      ...(i == null ? void 0 : i.page) && {
+        path: i.page.path,
+        title: i.page.title,
+        referrer: i.page.referrer
+      }
+    };
+    this.posthog.capture("$pageleave", r), this.log("Tracked page leave", { properties: s, context: i });
+  }
+  reset() {
+    !this.isEnabled() || !this.initialized || !this.posthog || !t() || (this.posthog.reset(), this.log("Reset user session"));
+  }
+}
+export {
+  n as P,
+  t as i
+};

package/dist/client.d.ts

@@ -1,7 +1,6 @@
 import { BrowserAnalytics } from './adapters/client/browser-analytics.js';
 import { AnalyticsProvider } from './core/events/types.js';
 import { EventMapFromCollection } from './core/events/index.js';
-type DefaultEventMap = Record<string, Record<string, unknown>>;
 export interface ClientAnalyticsConfig {
     providers?: AnalyticsProvider[];
     debug?: boolean;
@@ -35,12 +34,12 @@ export interface ClientAnalyticsConfig {
  * });
  * ```
  */
-export declare function createClientAnalytics<TEvents = never>(config: ClientAnalyticsConfig): BrowserAnalytics<EventMapFromCollection<TEvents>>;
+export declare function createClientAnalytics<TEvents = never, TUserTraits extends Record<string, unknown> = Record<string, unknown>>(config: ClientAnalyticsConfig): BrowserAnalytics<EventMapFromCollection<TEvents>, TUserTraits>;
 export { createClientAnalytics as createAnalytics };
 /**
  * Get the current analytics instance
  */
-export declare function getAnalytics(): BrowserAnalytics<DefaultEventMap>;
+export declare function getAnalytics(): BrowserAnalytics<Record<string, Record<string, unknown>>, Record<string, unknown>>;
 /**
  * Convenience function to track events
  */

package/dist/client.js

@@ -1,10 +1,10 @@
-var c = Object.defineProperty;
-var u = (t, e, i) => e in t ? c(t, e, { enumerable: !0, configurable: !0, writable: !0, value: i }) : t[e] = i;
-var n = (t, e, i) => u(t, typeof e != "symbol" ? e + "" : e, i);
-import { i as h } from "./client-RZPcOfAk.js";
-import { P } from "./client-RZPcOfAk.js";
-import { B as O } from "./base.provider-AfFL5W_P.js";
-class p {
+var u = Object.defineProperty;
+var h = (t, e, i) => e in t ? u(t, e, { enumerable: !0, configurable: !0, writable: !0, value: i }) : t[e] = i;
+var s = (t, e, i) => h(t, typeof e != "symbol" ? e + "" : e, i);
+import { i as p } from "./client-DTHZYkxx.js";
+import { P as b } from "./client-DTHZYkxx.js";
+import { B as C } from "./base.provider-AfFL5W_P.js";
+class f {
   /**
    * Creates a new BrowserAnalytics instance for client-side event tracking.
    * 
@@ -36,12 +36,13 @@ class p {
    * ```
    */
   constructor(e) {
-    n(this, "providers", []);
-    n(this, "context", {});
-    n(this, "userId");
-    n(this, "sessionId");
-    n(this, "initialized", !1);
-    n(this, "initializePromise");
+    s(this, "providers", []);
+    s(this, "context", {});
+    s(this, "userId");
+    s(this, "sessionId");
+    s(this, "userTraits");
+    s(this, "initialized", !1);
+    s(this, "initializePromise");
     this.providers = e.providers, e.defaultContext && (this.context = { ...e.defaultContext }), this.sessionId = this.generateSessionId();
   }
   /**
@@ -75,7 +76,7 @@ class p {
    * ```
    */
   async initialize() {
-    if (h() && !this.initialized)
+    if (p() && !this.initialized)
       return this.initializePromise ? this.initializePromise : (this.initializePromise = this._doInitialize(), this.initializePromise);
   }
   async _doInitialize() {
@@ -100,26 +101,31 @@ class p {
   }
   /**
    * Identifies a user with optional traits.
-   * 
+   *
    * Associates subsequent events with the specified user ID and optionally
    * sets user properties. This method should be called when a user logs in
    * or when you want to associate events with a known user.
-   * 
+   *
+   * **User Context (New):** User data (userId, email, traits) is automatically stored
+   * and included in all subsequent `track()` calls. This makes it easy for providers
+   * like Loops, Customer.io, or Intercom to access user information without passing
+   * it manually each time. The data is cleared when `reset()` is called (e.g., on logout).
+   *
    * The method automatically ensures initialization but doesn't block execution
    * if initialization is still in progress.
-   * 
+   *
    * @param userId Unique identifier for the user (e.g., database ID, email)
-   * @param traits Optional user properties and characteristics
-   * 
+   * @param traits Optional user properties and characteristics (email, name, plan, etc.)
+   *
    * @example
    * ```typescript
    * // Basic user identification
    * analytics.identify('user-123');
    * ```
-   * 
+   *
    * @example
    * ```typescript
-   * // Identify with user traits
+   * // Identify with user traits (recommended - enables email-based providers)
    * analytics.identify('user-123', {
    *   email: 'john@example.com',
    *   name: 'John Doe',
@@ -130,24 +136,38 @@ class p {
    *     notifications: false
    *   }
    * });
+   *
+   * // Now all subsequent track() calls automatically include user context
+   * analytics.track('button_clicked', { buttonId: 'checkout' });
+   * // Providers receive: context.user = { userId: 'user-123', email: 'john@example.com', traits: {...} }
    * ```
-   * 
+   *
    * @example
    * ```typescript
    * // In a login handler
    * async function handleLogin(email: string, password: string) {
    *   const user = await login(email, password);
-   *   
+   *
+   *   // Identify user with full traits
    *   analytics.identify(user.id, {
    *     email: user.email,
    *     name: user.name,
+   *     plan: user.plan,
+   *     company: user.company,
    *     lastLogin: new Date().toISOString()
    *   });
+   *
+   *   // All subsequent events now include this user context automatically
+   * }
+   *
+   * // In a logout handler - clear user context
+   * async function handleLogout() {
+   *   analytics.reset(); // Clears userId and traits
    * }
    * ```
    */
   identify(e, i) {
-    this.userId = e, this.ensureInitialized().catch((r) => {
+    this.userId = e, this.userTraits = i, this.ensureInitialized().catch((r) => {
       console.error("[Analytics] Failed to initialize during identify:", r);
     });
     for (const r of this.providers)
@@ -155,15 +175,19 @@ class p {
   }
   /**
    * Tracks a custom event with properties.
-   * 
+   *
    * This is the main method for tracking user interactions and business events.
    * The method ensures initialization before tracking and sends the event to all
    * configured providers. Events are enriched with context information like
    * timestamp, user ID, session ID, and browser context.
-   * 
+   *
+   * **User Context (New):** If `identify()` was called previously, user data (userId,
+   * email, traits) is automatically included in the event context sent to all providers.
+   * This happens transparently - you don't need to pass user data manually.
+   *
    * If providers are configured, the method waits for all providers to complete
    * tracking. Failed providers don't prevent others from succeeding.
-   * 
+   *
    * @param eventName Name of the event to track (must match your event definitions)
    * @param properties Event-specific properties and data
    * @returns Promise that resolves when tracking is complete for all providers
@@ -176,7 +200,20 @@ class p {
    *   page: '/landing'
    * });
    * ```
-   * 
+   *
+   * @example
+   * ```typescript
+   * // User context is automatically included after identify()
+   * analytics.identify('user-123', {
+   *   email: 'user@example.com',
+   *   plan: 'pro'
+   * });
+   *
+   * // Now all events automatically include user context
+   * analytics.track('button_clicked', { buttonId: 'checkout' });
+   * // Providers receive: context.user = { userId: 'user-123', email: 'user@example.com', traits: {...} }
+   * ```
+   *
    * @example
    * ```typescript
    * // Track a purchase event
@@ -191,14 +228,14 @@ class p {
    *   paymentMethod: 'credit_card'
    * });
    * ```
-   * 
+   *
    * @example
    * ```typescript
    * // Fire-and-forget for non-critical events (client-side typical usage)
    * analytics.track('feature_viewed', { feature: 'dashboard' });
    * // Don't await - let it track in the background
    * ```
-   * 
+   *
    * @example
    * ```typescript
    * // Error handling
@@ -220,17 +257,24 @@ class p {
       timestamp: Date.now(),
       userId: this.userId,
       sessionId: this.sessionId
-    }, o = this.providers.map(async (d) => {
+    }, o = {
+      ...this.context,
+      user: this.userId || this.userTraits ? {
+        userId: this.userId,
+        email: this.userTraits && "email" in this.userTraits ? this.userTraits.email : void 0,
+        traits: this.userTraits
+      } : void 0
+    }, l = this.providers.map(async (d) => {
       try {
-        await d.track(r, this.context);
-      } catch (l) {
+        await d.track(r, o);
+      } catch (c) {
         console.error(
           `[Analytics] Provider ${d.name} failed to track event:`,
-          l
+          c
         );
       }
     });
-    await Promise.all(o);
+    await Promise.all(l);
   }
   /**
    * Tracks a page view event.
@@ -420,7 +464,7 @@ class p {
    * ```
    */
   reset() {
-    this.userId = void 0, this.sessionId = this.generateSessionId();
+    this.userId = void 0, this.userTraits = void 0, this.sessionId = this.generateSessionId();
     for (const e of this.providers)
       e.reset();
   }
@@ -526,53 +570,51 @@ class p {
     return e.indexOf("Chrome") !== -1 ? "Chrome" : e.indexOf("Safari") !== -1 ? "Safari" : e.indexOf("Firefox") !== -1 ? "Firefox" : e.indexOf("Edge") !== -1 ? "Edge" : "Unknown";
   }
 }
-let s = null;
-function m(t) {
-  if (s)
-    return console.warn("[Analytics] Already initialized"), s;
+let n = null;
+function v(t) {
+  if (n)
+    return console.warn("[Analytics] Already initialized"), n;
   const e = {
     providers: t.providers || [],
     debug: t.debug,
     enabled: t.enabled
   };
-  return s = new p(
-    e
-  ), s.initialize().catch((i) => {
+  return n = new f(e), n.initialize().catch((i) => {
     console.error("[Analytics] Failed to initialize:", i);
-  }), s;
+  }), n;
 }
 function a() {
-  if (!s)
+  if (!n)
     throw new Error(
       "[Analytics] Not initialized. Call createAnalytics() first."
     );
-  return s;
+  return n;
 }
-function v(t, e) {
+function y(t, e) {
   return a().track(t, e);
 }
-function y(t, e) {
+function w(t, e) {
   a().identify(t, e);
 }
-function w(t) {
+function x(t) {
   a().pageView(t);
 }
 function z(t) {
   a().pageLeave(t);
 }
-function x() {
+function I() {
   a().reset();
 }
 export {
-  O as BaseAnalyticsProvider,
-  p as BrowserAnalytics,
-  P as PostHogClientProvider,
-  m as createAnalytics,
-  m as createClientAnalytics,
+  C as BaseAnalyticsProvider,
+  f as BrowserAnalytics,
+  b as PostHogClientProvider,
+  v as createAnalytics,
+  v as createClientAnalytics,
   a as getAnalytics,
-  y as identify,
+  w as identify,
   z as pageLeave,
-  w as pageView,
-  x as reset,
-  v as track
+  x as pageView,
+  I as reset,
+  y as track
 };

package/dist/core/events/types.d.ts

@@ -8,7 +8,13 @@ export interface BaseEvent {
     sessionId?: string;
     properties?: Record<string, unknown>;
 }
-export interface EventContext {
+export interface UserContext<TTraits extends Record<string, unknown> = Record<string, unknown>> {
+    userId?: string;
+    email?: string;
+    traits?: TTraits;
+}
+export interface EventContext<TTraits extends Record<string, unknown> = Record<string, unknown>> {
+    user?: UserContext<TTraits>;
     page?: {
         path: string;
         title?: string;