@xenia-martech/sdk-js 1.0.0-dev.25 → 1.0.0-dev.27

package/README.md

@@ -130,7 +130,7 @@ import { XeniaProvider } from "@xenia-martech/sdk-js/client/react";
 
 export default function App() {
   return (
-    <XeniaProvider baseUrl="/xenia" tenantId="t1" environmentKey="prod">
+    <XeniaProvider tenantId="t1" environmentKey="prod">
       {/* Declarative auto-tracking: data-xenia="<eventId>&<click|view-port|page-load>" */}
       <button data-xenia="checkout&click">Checkout</button>
       <section data-xenia="hero&view-port">Hero</section>
@@ -187,7 +187,7 @@ Every hook and component in this section is listed in full in the [API reference
 ```ts
 import { createXeniaClient } from "@xenia-martech/sdk-js/client";
 
-const xenia = createXeniaClient({ baseUrl: "/xenia", tenantId: "t1", environmentKey: "prod" });
+const xenia = createXeniaClient({ tenantId: "t1", environmentKey: "prod" });
 await xenia.init(); // resolves device id, starts data-xenia auto-tracking
 
 xenia.track("add_to_cart", { productId: "p1" }, { trigger: true });
@@ -207,7 +207,7 @@ import { createXeniaClient } from "@xenia-martech/sdk-js/client";
 
 export const XeniaPlugin = {
   install(app: App) {
-    const xenia = createXeniaClient({ baseUrl: "/xenia", tenantId: "t1", environmentKey: "prod" });
+    const xenia = createXeniaClient({ tenantId: "t1", environmentKey: "prod" });
     void xenia.init();
     app.provide("xenia", xenia);
     app.config.globalProperties.$xenia = xenia;
@@ -223,7 +223,6 @@ import { createXeniaClient, type XeniaClient } from "@xenia-martech/sdk-js/clien
 @Injectable({ providedIn: "root" })
 export class XeniaService implements OnDestroy {
   readonly client: XeniaClient = createXeniaClient({
-    baseUrl: "/xenia",
     tenantId: "t1",
     environmentKey: "prod",
   });
@@ -245,7 +244,7 @@ One script tag, then annotate elements. Exposes a global `window.Xenia`. Grab th
 ```html
 <script src="/js/xenia-sdk.iife.js"></script>
 <script>
-  Xenia.init({ baseUrl: "/xenia", tenantId: "t1", environmentKey: "prod" });
+  Xenia.init({ tenantId: "t1", environmentKey: "prod" });
   Xenia.consent({ analytics: true, marketing: false, personalization: false }); // nothing analytics-only sends until this is called
   // Xenia.identify("visitor-123");
 </script>
@@ -287,8 +286,8 @@ Serve tokens to the browser, and fire server-side events/webhooks/personalizatio
 import { createTokenRoute } from "@xenia-martech/sdk-js/server";
 
 export const GET = createTokenRoute({
-  baseUrl: process.env.XENIA_URL!,       // e.g. https://app.example.com/xenia
   sdkToken: process.env.XENIA_SDK_TOKEN!,
+  // baseUrl: process.env.XENIA_URL,      // only to override the default hosted engine
 });
 ```
 
@@ -300,10 +299,10 @@ Not on a framework with route handlers? Call the same exchange yourself with `re
 import { createXeniaServer } from "@xenia-martech/sdk-js/server";
 
 const xenia = createXeniaServer({
-  baseUrl: process.env.XENIA_URL!,
   tenantId: "t1",
   environmentKey: "prod",
   token: process.env.XENIA_TOKEN,
+  // baseUrl: process.env.XENIA_URL,      // only to override the default hosted engine
 });
 
 await xenia.track("purchase", {
@@ -354,7 +353,7 @@ Passed to `XeniaProvider`, `createXeniaClient`, `createXeniaServer`, or `Xenia.i
 
 | Option | Type | Default | Notes |
 |---|---|---|---|
-| `baseUrl` | `string` | — | Xenia base URL including `/xenia` (e.g. `/xenia` when same-origin). |
+| `baseUrl` | `string` | `https://engine.xeniamartech.com/xenia` | Xenia base URL. Override only for a self-hosted or non-default environment. |
 | `tenantId` | `string` | — | Sent as `X-Tenant-Id`. |
 | `environmentKey` | `string` | — | Sent as `X-Environment`. |
 | `token` | `string` | — | SDK Bearer token, sent as `Authorization: Bearer <token>` on every request. Required for `resolve()`/`resolveBatch()`; needed for events/webhooks only when a trigger node has its own auth token. |
@@ -494,7 +493,7 @@ function OfferCard({ action, close, fireCta }: XeniaMessageComponentProps) {
 }
 
 <XeniaProvider
-  baseUrl="/xenia" tenantId="t1" environmentKey="prod"
+  tenantId="t1" environmentKey="prod"
   messageComponent={reactMessageComponent(OfferCard)}
 >
   <App />
@@ -536,7 +535,27 @@ Each entry in `swaps` is `{ identifier, replacementEntryId, mode }` — `identif
 
 **Auth:** resolve **requires** the SDK Bearer token — the *same* `token` / `getToken` config as events (there is no separate personalization token). Events *optionally* send it (public otherwise); resolve *requires* it (401 without). Set it server-side; a browser without a token can still `track()` publicly but cannot `resolve()`.
 
-**Visitor id is attached automatically.** The SDK-owned visitor id (see [Analytics](#analytics--conversions)) is injected into the resolve `data` as `_xenia_vid`, so the backend can bucket holdout experiments and record per-visitor exposure — you don't add it yourself, and it can't be overridden per call. The webhook path (`request()` / `usePersonalization()`) carries the same id on the `/flow` body. Browser: resolved from `identify()`/device id; server: from `config.visitorId` (bind the `xenia_vid` cookie per request).
+**SDK-provided fields are attached automatically.** Every `resolve()`/`resolveBatch()` call carries a fixed set of fields into `data` — `path`, `query`, `deviceId`, `visitorId`, `customerId`, `email`, `url`, `referrer`, `utmSource`, `utmMedium`, `utmCampaign`, `utmContent`, `utmId` — plus the reserved `_xenia_vid` key the backend reads for holdout/exposure bucketing. These are the same "SDK-provided fields" a Personalization Resolve journey trigger exposes natively to downstream nodes. None of them can be overridden per call — the SDK's own values always win, even if your `data` happens to use one of these names.
+
+- **Browser:** collected ambiently — page URL/path/query/referrer/UTMs come from `window`/`document`; `visitorId`/`deviceId` from `identify()`/the auto-resolved device id; `customerId`/`email` from `identify(visitorId, { customerId, email })`. Nothing to configure.
+- **Server:** there's no ambient `window`/`document`, so bind the request **once** when you construct the per-request client and every call carries the fields automatically — no per-call wiring:
+
+  ```ts
+  import { createXeniaServer } from "@xenia-martech/sdk-js/server";
+  import { contextFromUrl } from "@xenia-martech/sdk-js";
+
+  const xenia = createXeniaServer({
+    tenantId, environmentKey, token,
+    visitorId: getVisitorId(cookieHeader),          // the browser's xenia_vid cookie
+    context: contextFromUrl(currentUrl, referrer),  // path / query / url / referrer / utm*
+  });
+
+  await xenia.resolve("hero");                      // ← fields already attached
+  ```
+
+  `contextFromUrl(url, referrer?)` derives the same fields the browser reads off `window.location`, so a rule can gate on `query.<name>` or `path` on a server-rendered page. In a framework where the render context can't see its own URL (e.g. a Next.js RSC), stamp the URL onto the request in middleware and read it back from `headers()` — see the `nextjs` example.
+
+  `opts.context`/`opts.identity` remain available per call, as an override on top of the ambient context or for values known only at that call site (e.g. `identity: { customerId: "c1", email: "a@b.com" }`). `visitorId`/`_xenia_vid` still come from `config.visitorId` and win over a per-call `identity.visitorId`. A client with neither bound behaves exactly as before.
 
 ```tsx
 import { usePersonalizationResolve } from "@xenia-martech/sdk-js/client/react";
@@ -662,39 +681,6 @@ Server-side, `XeniaServer.track(eventName, opts)` and `XeniaServer.identify(body
 
 Real wiring for the situations that come up once you're past "hello world" — pulled from working reference implementations, not hypotheticals.
 
-### Same-origin dev proxy (avoids CORS on `resolve()`)
-
-`resolve()`/`resolveBatch()` are auth-required and don't send wildcard-CORS headers, so they only work same-origin (or through a reverse proxy that presents them as same-origin). `track()`/`request()` are public and CORS-open, so this matters specifically for personalization.
-
-```ts
-// vite.config.ts
-export default defineConfig({
-  server: {
-    proxy: {
-      "/xenia": {
-        target: "http://localhost:8081",
-        changeOrigin: true,
-        // Strip Origin so the backend treats this as same-origin/server-to-server,
-        // not a cross-origin browser call it would otherwise 403 on the auth-required
-        // personalization endpoints.
-        configure: (proxy) => proxy.on("proxyReq", (req) => req.removeHeader("origin")),
-      },
-    },
-  },
-});
-```
-
-```ts
-// next.config.ts
-const nextConfig = {
-  async rewrites() {
-    return [{ source: "/xenia/:path*", destination: `${process.env.XENIA_URL}/:path*` }];
-  },
-};
-```
-
-Point `baseUrl: "/xenia"` (the default) at either proxy and `track`, `request`, **and** `resolve` all work with zero CORS configuration on the backend.
-
 ### Server actions — cart abandonment, checkout conversion
 
 A Next.js server-actions storefront, wiring `add_to_cart` to advance an abandoned-cart journey and `purchase` to record a conversion. The same shape applies to any backend framework.
@@ -709,11 +695,11 @@ const CONSENT = { analytics: true, marketing: true, personalization: true };
 
 export async function xeniaServer(visitorId?: string) {
   return createXeniaServer({
-    baseUrl: process.env.XENIA_URL!,
     tenantId: process.env.XENIA_TENANT_ID!,
     environmentKey: process.env.XENIA_ENV_KEY!,
     token: process.env.XENIA_SDK_TOKEN,
     visitorId,
+    // baseUrl: process.env.XENIA_URL,      // only to override the default hosted engine
   });
 }
 
@@ -808,7 +794,7 @@ function OfferBanner({ triggerId }: { triggerId: string }) {
 
 export function WelcomeOffer({ triggerId }: { triggerId: string }) {
   return (
-    <XeniaProvider baseUrl="/xenia" tenantId="t1" environmentKey="prod" getToken={getToken}>
+    <XeniaProvider tenantId="t1" environmentKey="prod" getToken={getToken}>
       <OfferBanner triggerId={triggerId} />
     </XeniaProvider>
   );

package/dist/{actions-DfuHrjUL.d.cts → actions-CkiSdvSa.d.cts}

@@ -40,15 +40,16 @@ interface RetryConfig {
 /**
  * Root configuration shared by client and server runtimes.
  *
- * Developers supply the minimum: `baseUrl` + tenant scope. Everything else
- * (identity, UTM, journey attribution, device id) is handled by the SDK.
+ * Developers supply the minimum: tenant scope. Everything else (identity,
+ * UTM, journey attribution, device id) is handled by the SDK.
  */
 interface XeniaConfig {
     /**
-     * Base URL of the Xenia backend, e.g. `https://app.example.com/xenia` or
-     * `/xenia` when same-origin (the FE proxies `/xenia/*`). No trailing slash.
+     * Base URL of the Xenia backend. Defaults to the hosted engine,
+     * `https://engine.xeniamartech.com/xenia` — omit this unless you're
+     * pointing at a self-hosted or non-default environment.
      */
-    baseUrl: string;
+    baseUrl?: string;
     /** Tenant id — sent as `X-Tenant-Id` on header-scoped endpoints. */
     tenantId: string;
     /** Environment key — sent as `X-Environment` on header-scoped endpoints. */
@@ -79,6 +80,23 @@ interface XeniaConfig {
      *   cookie read via `getVisitorId()`.
      */
     visitorId?: string;
+    /**
+     * The ambient request context for a **server** client — the SDK-provided page/campaign fields
+     * (`path`, `query`, `url`, `referrer`, `utmSource`/`utmMedium`/`utmCampaign`/`utmContent`/`utmId`)
+     * that get attached to EVERY `resolve()`/`resolveBatch()`/`webhook()` made with this client, so
+     * journey rules can gate on `query.<name>` or `path` without any per-call wiring.
+     *
+     * The browser client needs nothing here — it reads these off `window.location` itself. A server
+     * runtime has no ambient request, so bind it once when constructing the per-request client:
+     *
+     * ```ts
+     * createXeniaServer({ …, context: contextFromUrl(currentUrl, referrer) })
+     * ```
+     *
+     * Lowest precedence: a per-call `context`/`identity` overrides it, and the SDK-owned `visitorId`
+     * still wins over everything.
+     */
+    context?: EventContext;
     /**
      * Persist the SDK visitor id to a first-party `xenia_vid` cookie so your
      * **same-origin** server can read it (`getVisitorId(cookieHeader)`) and bind
@@ -114,6 +132,13 @@ interface VisitorCookieOptions {
     /** Cookie lifetime in days. Default 365. */
     maxAgeDays?: number;
 }
+/** Well-known event fields understood by the backend event-trigger node. */
+interface EventIdentity {
+    deviceId?: string;
+    visitorId?: string;
+    customerId?: string;
+    email?: string;
+}
 /** UTM + page context captured automatically by the client. */
 interface EventContext {
     utmSource?: string;
@@ -290,6 +315,23 @@ interface ResolveOptions {
     locale?: string;
     /** When true, ask the server to splice and return `content`. */
     merge?: boolean;
+    /**
+     * Caller-supplied identity fields (`deviceId`/`visitorId`/`customerId`/
+     * `email`), merged into `data` the same way `ServerWebhookOptions.identity`
+     * is merged for `webhook()`. Only relevant server-side — the browser client
+     * collects these ambiently instead and ignores this field. The SDK-owned
+     * `visitorId` (from `config.visitorId`) still wins over a value supplied
+     * here, same precedence as `webhook()`.
+     */
+    identity?: EventIdentity;
+    /**
+     * Caller-supplied page context (`path`/`query`/`url`/`referrer`/`utm*`),
+     * merged into `data` the same way `ServerWebhookOptions.context` is merged
+     * for `webhook()`. There's no ambient `window`/`document` server-side, so a
+     * server caller who wants these SDK-provided fields on a resolve() call
+     * must pass them explicitly (e.g. from the current request's headers).
+     */
+    context?: EventContext;
 }
 /** Body posted to `POST /api/events/v1/identify` — binds visitor to a known user. */
 interface IdentifyRequest {
@@ -426,7 +468,8 @@ type MessageComponentRenderer = (container: HTMLElement, ctx: MessageMountContex
 /**
  * Low-level, isomorphic Xenia API client. Wraps the raw endpoints; identity,
  * UTM capture, and action rendering are layered on top by the client runtime.
- * All paths are relative to `baseUrl` (which already includes `/xenia`).
+ * All paths are relative to `baseUrl`, which defaults to the hosted engine
+ * (`https://engine.xeniamartech.com/xenia`) when omitted from config.
  */
 declare class XeniaApi {
     private readonly http;
@@ -541,6 +584,10 @@ declare class Identity {
     /** Persist a visitor id so it rides on every future event. */
     identify(visitorId: string): void;
     getVisitorId(): string | null;
+    setCustomerId(customerId: string | null): void;
+    getCustomerId(): string | null;
+    setEmail(email: string | null): void;
+    getEmail(): string | null;
     /**
      * Resolve the current session id: reused while activity continues within
      * {@link SESSION_TIMEOUT_MS}, otherwise a new one is minted. Persisted in
@@ -626,8 +673,15 @@ declare class XeniaClient {
      * Persist a visitor id, attached to every subsequent event, and bind it to
      * a known user server-side (`POST /api/events/v1/identify`, fire-and-
      * forget — resolves to an `"identify"` client event carrying `personId`).
+     *
+     * `extra.customerId`/`extra.email`, when supplied, are also persisted
+     * ambiently (like the visitor id) so they ride on every later `resolve()`
+     * call automatically — part of the SDK-provided-fields parity list.
      */
-    identify(visitorId: string): void;
+    identify(visitorId: string, extra?: {
+        customerId?: string;
+        email?: string;
+    }): void;
     /** Override the customer-journey UUID (else derived from utm_id). */
     setJourneyId(id: string | null): void;
     /**
@@ -673,10 +727,18 @@ declare class XeniaClient {
     /** The SDK-owned visitor anchor: the `identify()`/`config.visitorId` id, else the device id. */
     private resolveVisitorId;
     /**
-     * Stamp the SDK-owned visitor id into the resolve `data` under the reserved
-     * `_xenia_vid` key so the backend can bucket holdout experiments and record
-     * exposure per visitor (it reads visitor identity from `data`). Set last so a
-     * caller can't override it; a no-op when no visitor id is resolvable yet.
+     * Stamp the full set of SDK-provided fields into the resolve `data` —
+     * `path`, `query`, `deviceId`, `visitorId`, `customerId`, `email`, `url`,
+     * `referrer`, and the five `utm*` fields — the same field-name/type parity
+     * the webhook trigger's "SDK-provided fields" already promises, now native
+     * (always attached, no marketer toggle) for the Personalization Resolve
+     * trigger too. Plus the reserved `_xenia_vid` key the backend reads for
+     * holdout/exposure bucketing. All of these are spread LAST (after the
+     * caller's own `data`) so none can be overridden per call — the same
+     * override-protection guarantee `_xenia_vid` alone used to have, now
+     * widened to the full set. A no-op (returns `opts` unchanged) when nothing
+     * is resolvable yet (e.g. called before `init()` on a fresh visit with no
+     * page context available).
      */
     private withVisitor;
     private dntBlocked;

package/dist/{actions-DfuHrjUL.d.ts → actions-CkiSdvSa.d.ts}

@@ -40,15 +40,16 @@ interface RetryConfig {
 /**
  * Root configuration shared by client and server runtimes.
  *
- * Developers supply the minimum: `baseUrl` + tenant scope. Everything else
- * (identity, UTM, journey attribution, device id) is handled by the SDK.
+ * Developers supply the minimum: tenant scope. Everything else (identity,
+ * UTM, journey attribution, device id) is handled by the SDK.
  */
 interface XeniaConfig {
     /**
-     * Base URL of the Xenia backend, e.g. `https://app.example.com/xenia` or
-     * `/xenia` when same-origin (the FE proxies `/xenia/*`). No trailing slash.
+     * Base URL of the Xenia backend. Defaults to the hosted engine,
+     * `https://engine.xeniamartech.com/xenia` — omit this unless you're
+     * pointing at a self-hosted or non-default environment.
      */
-    baseUrl: string;
+    baseUrl?: string;
     /** Tenant id — sent as `X-Tenant-Id` on header-scoped endpoints. */
     tenantId: string;
     /** Environment key — sent as `X-Environment` on header-scoped endpoints. */
@@ -79,6 +80,23 @@ interface XeniaConfig {
      *   cookie read via `getVisitorId()`.
      */
     visitorId?: string;
+    /**
+     * The ambient request context for a **server** client — the SDK-provided page/campaign fields
+     * (`path`, `query`, `url`, `referrer`, `utmSource`/`utmMedium`/`utmCampaign`/`utmContent`/`utmId`)
+     * that get attached to EVERY `resolve()`/`resolveBatch()`/`webhook()` made with this client, so
+     * journey rules can gate on `query.<name>` or `path` without any per-call wiring.
+     *
+     * The browser client needs nothing here — it reads these off `window.location` itself. A server
+     * runtime has no ambient request, so bind it once when constructing the per-request client:
+     *
+     * ```ts
+     * createXeniaServer({ …, context: contextFromUrl(currentUrl, referrer) })
+     * ```
+     *
+     * Lowest precedence: a per-call `context`/`identity` overrides it, and the SDK-owned `visitorId`
+     * still wins over everything.
+     */
+    context?: EventContext;
     /**
      * Persist the SDK visitor id to a first-party `xenia_vid` cookie so your
      * **same-origin** server can read it (`getVisitorId(cookieHeader)`) and bind
@@ -114,6 +132,13 @@ interface VisitorCookieOptions {
     /** Cookie lifetime in days. Default 365. */
     maxAgeDays?: number;
 }
+/** Well-known event fields understood by the backend event-trigger node. */
+interface EventIdentity {
+    deviceId?: string;
+    visitorId?: string;
+    customerId?: string;
+    email?: string;
+}
 /** UTM + page context captured automatically by the client. */
 interface EventContext {
     utmSource?: string;
@@ -290,6 +315,23 @@ interface ResolveOptions {
     locale?: string;
     /** When true, ask the server to splice and return `content`. */
     merge?: boolean;
+    /**
+     * Caller-supplied identity fields (`deviceId`/`visitorId`/`customerId`/
+     * `email`), merged into `data` the same way `ServerWebhookOptions.identity`
+     * is merged for `webhook()`. Only relevant server-side — the browser client
+     * collects these ambiently instead and ignores this field. The SDK-owned
+     * `visitorId` (from `config.visitorId`) still wins over a value supplied
+     * here, same precedence as `webhook()`.
+     */
+    identity?: EventIdentity;
+    /**
+     * Caller-supplied page context (`path`/`query`/`url`/`referrer`/`utm*`),
+     * merged into `data` the same way `ServerWebhookOptions.context` is merged
+     * for `webhook()`. There's no ambient `window`/`document` server-side, so a
+     * server caller who wants these SDK-provided fields on a resolve() call
+     * must pass them explicitly (e.g. from the current request's headers).
+     */
+    context?: EventContext;
 }
 /** Body posted to `POST /api/events/v1/identify` — binds visitor to a known user. */
 interface IdentifyRequest {
@@ -426,7 +468,8 @@ type MessageComponentRenderer = (container: HTMLElement, ctx: MessageMountContex
 /**
  * Low-level, isomorphic Xenia API client. Wraps the raw endpoints; identity,
  * UTM capture, and action rendering are layered on top by the client runtime.
- * All paths are relative to `baseUrl` (which already includes `/xenia`).
+ * All paths are relative to `baseUrl`, which defaults to the hosted engine
+ * (`https://engine.xeniamartech.com/xenia`) when omitted from config.
  */
 declare class XeniaApi {
     private readonly http;
@@ -541,6 +584,10 @@ declare class Identity {
     /** Persist a visitor id so it rides on every future event. */
     identify(visitorId: string): void;
     getVisitorId(): string | null;
+    setCustomerId(customerId: string | null): void;
+    getCustomerId(): string | null;
+    setEmail(email: string | null): void;
+    getEmail(): string | null;
     /**
      * Resolve the current session id: reused while activity continues within
      * {@link SESSION_TIMEOUT_MS}, otherwise a new one is minted. Persisted in
@@ -626,8 +673,15 @@ declare class XeniaClient {
      * Persist a visitor id, attached to every subsequent event, and bind it to
      * a known user server-side (`POST /api/events/v1/identify`, fire-and-
      * forget — resolves to an `"identify"` client event carrying `personId`).
+     *
+     * `extra.customerId`/`extra.email`, when supplied, are also persisted
+     * ambiently (like the visitor id) so they ride on every later `resolve()`
+     * call automatically — part of the SDK-provided-fields parity list.
      */
-    identify(visitorId: string): void;
+    identify(visitorId: string, extra?: {
+        customerId?: string;
+        email?: string;
+    }): void;
     /** Override the customer-journey UUID (else derived from utm_id). */
     setJourneyId(id: string | null): void;
     /**
@@ -673,10 +727,18 @@ declare class XeniaClient {
     /** The SDK-owned visitor anchor: the `identify()`/`config.visitorId` id, else the device id. */
     private resolveVisitorId;
     /**
-     * Stamp the SDK-owned visitor id into the resolve `data` under the reserved
-     * `_xenia_vid` key so the backend can bucket holdout experiments and record
-     * exposure per visitor (it reads visitor identity from `data`). Set last so a
-     * caller can't override it; a no-op when no visitor id is resolvable yet.
+     * Stamp the full set of SDK-provided fields into the resolve `data` —
+     * `path`, `query`, `deviceId`, `visitorId`, `customerId`, `email`, `url`,
+     * `referrer`, and the five `utm*` fields — the same field-name/type parity
+     * the webhook trigger's "SDK-provided fields" already promises, now native
+     * (always attached, no marketer toggle) for the Personalization Resolve
+     * trigger too. Plus the reserved `_xenia_vid` key the backend reads for
+     * holdout/exposure bucketing. All of these are spread LAST (after the
+     * caller's own `data`) so none can be overridden per call — the same
+     * override-protection guarantee `_xenia_vid` alone used to have, now
+     * widened to the full set. A no-op (returns `opts` unchanged) when nothing
+     * is resolvable yet (e.g. called before `init()` on a fresh visit with no
+     * page context available).
      */
     private withVisitor;
     private dntBlocked;

package/dist/{chunk-PTYUK4P3.js → chunk-7D2HJMW6.js}

@@ -85,6 +85,7 @@ function parseActions(body) {
 }
 
 // src/core/http-client.ts
+var DEFAULT_BASE_URL = "https://engine.xeniamartech.com/xenia";
 function isBrowser() {
   return typeof window !== "undefined" && typeof document !== "undefined";
 }
@@ -114,7 +115,7 @@ var HttpClient = class {
   retry;
   debug;
   constructor(opts) {
-    this.baseUrl = opts.baseUrl.replace(/\/+$/, "");
+    this.baseUrl = (opts.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
     this.defaultHeaders = opts.defaultHeaders ?? {};
     this.timeout = opts.timeout ?? 8e3;
     this.retry = {
@@ -515,6 +516,34 @@ function extractContentSwaps(body) {
   return Array.isArray(swaps) ? swaps : void 0;
 }
 
+// src/core/request-context.ts
+function contextFromUrl(url, referrer) {
+  const ctx = {};
+  if (referrer) ctx.referrer = referrer;
+  if (!url) return ctx;
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return ctx;
+  }
+  ctx.url = parsed.href;
+  ctx.path = parsed.pathname;
+  ctx.query = Object.fromEntries(parsed.searchParams);
+  const utm = (name) => parsed.searchParams.get(name) || void 0;
+  const utmSource = utm("utm_source");
+  const utmMedium = utm("utm_medium");
+  const utmCampaign = utm("utm_campaign");
+  const utmContent = utm("utm_content");
+  const utmId = utm("utm_id");
+  if (utmSource) ctx.utmSource = utmSource;
+  if (utmMedium) ctx.utmMedium = utmMedium;
+  if (utmCampaign) ctx.utmCampaign = utmCampaign;
+  if (utmContent) ctx.utmContent = utmContent;
+  if (utmId) ctx.utmId = utmId;
+  return ctx;
+}
+
 // src/core/response-store.ts
 var MemoryResponseStore = class {
   map = /* @__PURE__ */ new Map();
@@ -569,6 +598,6 @@ var LocalStorageResponseStore = class {
   }
 };
 
-export { CONSENT_COOKIE, DEFAULT_PREFIX, HttpClient, HttpError, LocalStorageResponseStore, MAX_EVENT_ID_LENGTH, MemoryResponseStore, VISITOR_COOKIE, XeniaApi, buildUrl, consentCookieName, extractContentSwaps, generateUlid, isBrowser, parseActions, spliceSlots, toEventId, visitorCookieName };
-//# sourceMappingURL=chunk-PTYUK4P3.js.map
-//# sourceMappingURL=chunk-PTYUK4P3.js.map
+export { CONSENT_COOKIE, DEFAULT_PREFIX, HttpClient, HttpError, LocalStorageResponseStore, MAX_EVENT_ID_LENGTH, MemoryResponseStore, VISITOR_COOKIE, XeniaApi, buildUrl, compact, consentCookieName, contextFromUrl, extractContentSwaps, generateUlid, isBrowser, parseActions, spliceSlots, toEventId, visitorCookieName };
+//# sourceMappingURL=chunk-7D2HJMW6.js.map
+//# sourceMappingURL=chunk-7D2HJMW6.js.map