@amplitude/experiment-tag 0.25.1 → 0.26.0

package/dist/types/src/behavioral-targeting/behavioral-targeting-manager.d.ts

@@ -1,4 +1,6 @@
 import { BehavioralTargetingRules } from '../types';
+import { RelayClient } from './relay-client';
+import { RelaySyncResult } from './relay-sync-result';
 /**
  * Manages all behavioral targeting functionality including event storage,
  * session management, and rule evaluation.
@@ -10,7 +12,7 @@ export declare class BehavioralTargetingManager {
     private readonly rules;
     private readonly matchedBehaviors;
     private readonly eventToBehaviors;
-    constructor(apiKey: string, initialRules?: BehavioralTargetingRules);
+    constructor(apiKey: string, initialRules?: BehavioralTargetingRules, sessionTimeoutMs?: number);
     /**
      * Track an event for behavioral targeting evaluation.
      * Automatically updates the active behavior state for affected flags.
@@ -18,6 +20,19 @@ export declare class BehavioralTargetingManager {
      * @param properties Event properties
      */
     trackEvent(eventType: string, properties: Record<string, unknown>): void;
+    /**
+     * Attach the relay client for cross-subdomain event dual-write.
+     */
+    setRelayClient(relayClient: RelayClient | null): void;
+    /**
+     * Inject relay iframe (non-blocking init) and run the relay merge.
+     *
+     * This only reads/merges relay state and reports the outcome; it never
+     * attaches the relay for dual-write. The caller owns relay lifecycle and
+     * decides whether to attach (via {@link setRelayClient}) based on the
+     * result and whether this client is still the active one.
+     */
+    beginRelaySync(relayClient: RelayClient): Promise<RelaySyncResult>;
     /**
      * Check if a flag has behavioral targeting rules.
      * @param flagKey The flag key to check
@@ -63,6 +78,11 @@ export declare class BehavioralTargetingManager {
      * @param flagKey The flag key to evaluate
      */
     private evaluateFlag;
+    /**
+     * Stable JSON snapshot of matched behaviors (sorted behavior IDs per flag),
+     * used to detect whether a relay sync changed the matched set.
+     */
+    private serializeMatchedBehaviors;
     /**
      * Evaluate a specific behavior ID for a flag.
      * Updates only the specified behavior ID in the matchedBehaviors state.

package/dist/types/src/behavioral-targeting/event-storage.d.ts

@@ -1,8 +1,25 @@
+import { RelayClient } from './relay-client';
+import { RelayEventStorage } from './relay-protocol';
 import { SessionManager } from './session-manager';
+/**
+ * Dedup key for cross-subdomain merge. Uses the event's uuid (minted once at
+ * creation in {@link EventStorageManager.addEvent}) so the SDK and relay.js
+ * agree on identity. (event_type + timestamp is not unique — two distinct
+ * same-type events in the same millisecond would collapse.)
+ */
+export declare function eventDedupKey(event: {
+    uuid: string;
+}): string;
 /**
  * Represents a stored event record.
  */
 export interface EventRecord {
+    /** Stable per-event identity; the cross-subdomain dedup key (see eventDedupKey). */
+    uuid: string;
+    /**
+     * Per-origin monotonic counter. Retained for debugging only — identity and
+     * dedup use uuid, ordering uses timestamp, and FIFO uses array order.
+     */
     id: number;
     event_type: string;
     timestamp: number;
@@ -22,6 +39,7 @@ export declare class EventStorageManager {
     private hasPendingWrites;
     private persistedEvents?;
     private storageKey;
+    private relayClient;
     constructor(apiKey: string, sessionManager: SessionManager, persistedEvents?: Set<string>);
     /**
      * Adds an event to in-memory cache with automatic session tracking.
@@ -29,6 +47,23 @@ export declare class EventStorageManager {
      * If persistedEvents is set, only events with matching event types will be stored.
      */
     addEvent(eventType: string, properties?: Record<string, unknown>, eventTime?: number): void;
+    /**
+     * Attach or detach the relay client for cross-subdomain dual-write.
+     */
+    setRelayClient(relayClient: RelayClient | null): void;
+    /**
+     * Flushes pending relay writes (e.g. on page unload).
+     */
+    flushRelay(): void;
+    /**
+     * Merges relay events into the in-memory cache. Relay wins on dedup conflicts.
+     */
+    mergeFromRelay(relayStore: RelayEventStorage): void;
+    /**
+     * Pass 2 sync: migrate local store to relay if needed, then merge relay events.
+     * Returns true when sync completed; false when relay unavailable or RPC failed.
+     */
+    syncFromRelay(relayClient?: RelayClient): Promise<boolean>;
     /**
      * Gets all events from in-memory cache (for testing/debugging).
      */

package/dist/types/src/behavioral-targeting/index.d.ts

@@ -1,2 +1,4 @@
 export { BehavioralTargetingManager } from './behavioral-targeting-manager';
 export { BehavioralTargeting, BehavioralCondition, BehavioralConditionSet, } from './types';
+export * from './relay-protocol';
+export * from './relay-client';

package/dist/types/src/behavioral-targeting/relay-client.d.ts

@@ -0,0 +1,40 @@
+import { RelayEventRecord, RelayEventStorage } from './relay-protocol';
+export declare function getRelayUrl(apiKey: string, serverZone?: string, relayUrl?: string): string;
+export declare class RelayClient {
+    private readonly apiKey;
+    private readonly webExpIdV2;
+    private readonly relayUrl;
+    private iframe;
+    private iframeWindow;
+    private relayOrigin;
+    private available;
+    private pendingWrites;
+    private readonly pendingRequests;
+    private messageListener;
+    private initPromise;
+    private initTimeoutId;
+    private initResolve;
+    private cancelBodyReadyPoll;
+    private destroyed;
+    private availablePromise;
+    private resolveAvailable;
+    constructor(apiKey: string, webExpIdV2: string, relayUrl: string);
+    private createRelayRequest;
+    get relayAvailable(): boolean;
+    private notifyAvailable;
+    /**
+     * Resolves when the relay becomes available, or after timeout.
+     * Use after init() when the init timer may have fired before RELAY_READY.
+     */
+    waitForAvailable(timeoutMs?: number): Promise<boolean>;
+    init(): Promise<void>;
+    private sendRequest;
+    readEvents(): Promise<RelayEventStorage>;
+    writeEvent(event: RelayEventRecord): void;
+    private removeConfirmedWrite;
+    private sendPendingWrite;
+    flush(): void;
+    checkMigrated(origin: string): Promise<boolean>;
+    migrateEvents(origin: string, store: RelayEventStorage): Promise<void>;
+    destroy(): void;
+}

package/dist/types/src/behavioral-targeting/relay-protocol.d.ts

@@ -0,0 +1,36 @@
+export declare const RELAY_READY_MESSAGE = "AMP_RELAY_READY";
+export declare const RELAY_RPC_TIMEOUT_MS = 2000;
+export type RelayMessageType = 'WRITE_EVENT' | 'READ_EVENTS' | 'MIGRATE_EVENTS' | 'CHECK_MIGRATED' | 'MIGRATE_ACK';
+export interface RelayEventRecord {
+    /** Stable per-event identity minted by the SDK; the cross-subdomain dedup key. */
+    uuid: string;
+    id: number;
+    event_type: string;
+    timestamp: number;
+    session_id: string;
+    properties: Record<string, unknown>;
+}
+export interface RelayEventStorage {
+    events: RelayEventRecord[];
+    nextId: number;
+}
+export interface RelayRequest {
+    type: RelayMessageType;
+    requestId: string;
+    apiKey: string;
+    web_exp_id_v2: string;
+    payload?: unknown;
+}
+export interface RelayResponse {
+    requestId: string;
+    ok: boolean;
+    payload?: unknown;
+    error?: string;
+}
+export interface MigratePayload {
+    sourceOrigin: string;
+    store: RelayEventStorage;
+}
+export interface WriteEventPayload {
+    event: RelayEventRecord;
+}

package/dist/types/src/behavioral-targeting/relay-sync-result.d.ts

@@ -0,0 +1,10 @@
+/** Outcome of non-blocking relay iframe init + relay merge. */
+export type RelaySyncResult = {
+    status: 'behaviors_changed';
+} | {
+    status: 'unchanged';
+} | {
+    status: 'unavailable';
+} | {
+    status: 'sync_failed';
+};

package/dist/types/src/behavioral-targeting/session-manager.d.ts

@@ -1,27 +1,57 @@
 /**
- * Manages browser session ID using sessionStorage.
- * Session ID is unique per browser tab and cleared when tab closes.
+ * Default rolling inactivity window before a session rotates, mirroring
+ * Amplitude Analytics' 30-minute session timeout.
+ */
+export declare const DEFAULT_SESSION_TIMEOUT_MS: number;
+/**
+ * Manages the RTBT session ID.
+ *
+ * Unlike the previous per-tab `sessionStorage` implementation, the session is
+ * persisted in a root-domain cookie so it is shared across subdomains, and it
+ * rotates on a rolling inactivity timeout (the same model Amplitude Analytics
+ * uses). When cookies are unavailable (private browsing, ITP, blocked I/O) the
+ * session degrades gracefully to an in-memory, per-page session.
+ *
+ * Cookie I/O + the cookie→memory two-tier fallback are delegated to
+ * {@link SyncJsonCookie}; this class owns the session lifecycle (rotation on
+ * inactivity, validation) on top of it.
  */
 export declare class SessionManager {
-    private storageKey;
-    private sessionId?;
-    private sessionStartTime?;
-    constructor(apiKey: string);
+    private sessionTimeoutMs;
+    private store;
+    /** Lazily resolved leading-dot domain (e.g. `.example.com`) or `''`. */
+    private resolvedDomain?;
+    constructor(apiKey: string, sessionTimeoutMs?: number);
+    /**
+     * Returns the current session ID, rotating it when the inactivity timeout
+     * has elapsed and creating one when none exists. This is a read: it does not
+     * extend the session (use {@link recordActivity} for that).
+     */
+    getCurrentSessionId(): string;
     /**
-     * Gets the current session ID, creating one if it doesn't exist.
-     * Uses sessionStorage (cleared when tab closes).
+     * Backwards-compatible alias for {@link getCurrentSessionId}.
      */
     getOrCreateSessionId(): string;
+    /**
+     * Records activity for the current page event: extends the active session
+     * (bumping `lastEventTime`) or rotates to a new session when the inactivity
+     * timeout has elapsed. Call this for every observed Amplitude event so that
+     * any activity keeps the session alive.
+     */
+    recordActivity(): void;
     /**
      * Gets the session start time in milliseconds since epoch.
      */
     getSessionStartTime(): number | undefined;
     /**
-     * Generates a unique session ID.
+     * Clears the current session from memory and cookie storage.
      */
-    private generateSessionId;
+    clearSession(): void;
     /**
-     * Clears the current session (for testing).
+     * Resolves the active session: returns the persisted session when it is
+     * still within the inactivity window, otherwise creates, persists and
+     * returns a fresh one. Does not extend an already-active session.
      */
-    clearSession(): void;
+    private resolve;
+    private domain;
 }

package/dist/types/src/experiment.d.ts

@@ -31,6 +31,7 @@ export declare class DefaultWebExperimentClient implements WebExperimentClient {
     private readonly localFlagKeys;
     private remoteFlagKeys;
     private isRemoteBlocking;
+    isRedirecting: boolean;
     private customRedirectHandler;
     isRunning: boolean;
     private readonly messageBus;
@@ -38,11 +39,13 @@ export declare class DefaultWebExperimentClient implements WebExperimentClient {
     private activePages;
     private readonly behavioralTargetingRules;
     readonly behavioralTargetingManager: BehavioralTargetingManager | undefined;
+    private relayClient;
     private subscriptionManager;
     private isVisualEditorMode;
     private isDebugActive;
     isPreviewMode: boolean;
     previewFlags: Record<string, string>;
+    private rootDomain;
     constructor(apiKey: string, initConfigs: InitConfigs, config?: WebExperimentConfig);
     /**
      * Start the web experiment client.
@@ -98,6 +101,26 @@ export declare class DefaultWebExperimentClient implements WebExperimentClient {
      * @returns An unsubscribe function to remove the subscriber.
      */
     addPageChangeSubscriber(callback: (event: PageChangeEvent) => void): (() => void) | undefined;
+    /**
+     * Behavioral targeting evaluates in two phases at startup:
+     *
+     *  1. start() evaluates and applies variants from this origin's own local
+     *     event store (already done by the time we get here).
+     *  2. Relay sync (this method): a hidden CDN iframe pulls the shared
+     *     cross-subdomain event store, merges it into local storage, and
+     *     re-evaluates behavioral targeting. If matched behaviors changed,
+     *     {@link reapplyVariantsAfterRelaySync} re-applies the affected variants.
+     *
+     * Non-blocking: the iframe init and merge run after anti-flicker is removed,
+     * so a relay-driven change repaints rather than delaying first paint.
+     */
+    private scheduleRelaySync;
+    private teardownRelay;
+    /**
+     * Re-apply variants when a relay sync changed the matched behaviors
+     * (phase 2 of the startup described on {@link scheduleRelaySync}).
+     */
+    private reapplyVariantsAfterRelaySync;
     /**
      * Update the user with matched behavioral targeting IDs.
      * Sets the user property `behavioral_targeting` to an array of all matched behavior IDs.

package/dist/types/src/subscriptions/subscription-refactor.d.ts

@@ -1,3 +1,4 @@
+import { type GlobalScope } from '@amplitude/experiment-core';
 import { DefaultWebExperimentClient } from '../experiment';
 import { PageObjects } from '../types';
 import { MessageBus } from './message-bus';
@@ -17,7 +18,7 @@ export declare class SubscriptionManager {
     private triggerManagers;
     private pageChangeSubscribers;
     private lastNotifiedActivePages;
-    constructor(webExperimentClient: DefaultWebExperimentClient, messageBus: MessageBus, pageObjects: PageObjects, options: initOptions, globalScope: typeof globalThis);
+    constructor(webExperimentClient: DefaultWebExperimentClient, messageBus: MessageBus, pageObjects: PageObjects, options: initOptions, globalScope: GlobalScope);
     setPageObjects: (pageObjects: PageObjects) => void;
     markUrlAsPublished: (url: string) => void;
     initSubscriptions: () => void;

package/dist/types/src/subscriptions/subscriptions.d.ts

@@ -1,3 +1,4 @@
+import { type GlobalScope } from '@amplitude/experiment-core';
 import { BehavioralTargetingManager } from '../behavioral-targeting';
 import { DefaultWebExperimentClient } from '../experiment';
 import { PageObjects } from '../types';
@@ -42,7 +43,7 @@ export declare class SubscriptionManager {
     private debugDebounceTimer;
     private get contentDocument();
     private get contentWindow();
-    constructor(webExperimentClient: DefaultWebExperimentClient, messageBus: MessageBus, pageObjects: PageObjects, behavioralTargetingManager: BehavioralTargetingManager | undefined, options: initOptions, globalScope: typeof globalThis);
+    constructor(webExperimentClient: DefaultWebExperimentClient, messageBus: MessageBus, pageObjects: PageObjects, behavioralTargetingManager: BehavioralTargetingManager | undefined, options: initOptions, globalScope: GlobalScope);
     setPageObjects: (pageObjects: PageObjects) => void;
     markUrlAsPublished: (url: string) => void;
     initSubscriptions: () => void;

package/dist/types/src/triggers/base-trigger-manager.d.ts

@@ -1,3 +1,4 @@
+import type { GlobalScope } from '@amplitude/experiment-core';
 import { MessageBus, MessagePayloads, MessageType } from '../subscriptions/message-bus';
 import { PageObject } from '../types';
 import { TriggerManagerOptions } from './index';
@@ -46,9 +47,9 @@ export interface TriggerManager<TPayload = any> {
 export declare abstract class BaseTriggerManager<TPayload = any> implements TriggerManager<TPayload> {
     protected readonly pageObjects: PageObject[];
     protected readonly messageBus: MessageBus;
-    protected readonly globalScope: typeof globalThis;
+    protected readonly globalScope: GlobalScope;
     protected readonly options?: TriggerManagerOptions | undefined;
-    constructor(pageObjects: PageObject[], messageBus: MessageBus, globalScope: typeof globalThis, options?: TriggerManagerOptions | undefined);
+    constructor(pageObjects: PageObject[], messageBus: MessageBus, globalScope: GlobalScope, options?: TriggerManagerOptions | undefined);
     abstract readonly triggerType: MessageType;
     abstract initialize(): void;
     abstract isActive(page: PageObject, payload?: TPayload): boolean;

package/dist/types/src/triggers/index.d.ts

@@ -1,3 +1,4 @@
+import type { GlobalScope } from '@amplitude/experiment-core';
 import { MessageBus, MessageType } from '../subscriptions/message-bus';
 import { PageObject } from '../types';
 import { TriggerManager } from './base-trigger-manager';
@@ -17,4 +18,4 @@ type TriggerType = Exclude<MessageType, 'element_appeared_internal'>;
  * Registry of trigger managers available in this version.
  * Trigger managers will be added in subsequent PRs.
  */
-export declare const TRIGGER_MANAGER_REGISTRY: Partial<Record<TriggerType, new (pageObjects: PageObject[], messageBus: MessageBus, globalScope: typeof globalThis, options?: TriggerManagerOptions) => TriggerManager>>;
+export declare const TRIGGER_MANAGER_REGISTRY: Partial<Record<TriggerType, new (pageObjects: PageObject[], messageBus: MessageBus, globalScope: GlobalScope, options?: TriggerManagerOptions) => TriggerManager>>;

package/dist/types/src/types.d.ts

@@ -101,6 +101,20 @@ export interface WebExperimentConfig extends ExperimentConfig {
      */
     useDefaultNavigationHandler?: boolean;
     redirectConfig?: RedirectConfig;
+    /**
+     * Rolling inactivity timeout, in milliseconds, after which the behavioral
+     * targeting (RTBT) session rotates. Mirrors Amplitude Analytics' session
+     * model. Defaults to 30 minutes when unset.
+     */
+    rtbtSessionTimeout?: number;
+    /**
+     * Overrides the origin the cross-subdomain RTBT relay iframe is loaded from.
+     * Provide a scheme + host (+ optional port), e.g. `https://relay.lvh.me:3036`;
+     * the canonical `/script/{apiKey}.relay.html` path is appended automatically.
+     * When unset, the relay loads from the Amplitude CDN for the configured server
+     * zone. Intended for local/staging testing of the relay serving path.
+     */
+    relayUrl?: string;
 }
 export declare const Defaults: WebExperimentConfig;
 /**

package/dist/types/src/util/cookie.d.ts

@@ -1,11 +1,61 @@
 import { CookieStorage } from '@amplitude/analytics-core';
+/**
+ * Synchronous variant of {@link getTopLevelDomain}. Resolves the registrable
+ * (root) domain for `hostname` so callers can set a cookie shared across
+ * subdomains, without the async `CookieStorage.isDomainWritable` round-trip.
+ * Returns a leading-dot domain (e.g. `.example.com`) or `''` when no
+ * cross-subdomain domain is writable (single-label hosts, IPs, blocked I/O).
+ */
+export declare function getTopLevelDomainSync(hostname: string): string;
 export declare function getTopLevelDomain(hostname: string): Promise<string>;
 /**
- * Resolves a cross-subdomain value using cookie storage as the authoritative
- * source. Falls back to a provided localStorage value (migration path), then
- * generates a new value if neither exists. Attempts to set the cookie when
- * missing; cookie I/O failures fall back to localStorage / generateNew.
- * Callers are responsible for syncing the returned value back to localStorage.
+ * Resolves several cross-subdomain fields from a single cookie, using cookie
+ * storage as the authoritative source. Each field falls back to its `fallback`
+ * value (migration path), then its generator. One read + at most one write;
+ * cookie I/O failures degrade to the returned value. Callers are responsible
+ * for mirroring values back to localStorage if needed.
+ */
+export declare function resolveCrossSubdomainObject<T extends Record<string, string>>(cookieStorage: CookieStorage<string>, cookieKey: string, fallback: Partial<T>, generators: {
+    [K in keyof T]: () => string;
+}): Promise<T>;
+/** Reads a raw cookie value (URL-decoded) synchronously, or `undefined` if absent. */
+export declare function readRawCookie(key: string): string | undefined;
+/**
+ * Writes a cookie (`Path=/; SameSite=Lax`, `Secure` on https), then verifies it
+ * via read-back. Returns `false` on blocked cookie I/O (private mode, ITP, a
+ * wrong domain) so callers can fall back to memory. No `maxAgeSeconds` ⇒ session.
+ *
+ * The read-back compares the decoded value, not just key presence: a silently
+ * dropped write that leaves a stale same-key cookie (e.g. a host-only cookie
+ * shadowing a failed `.domain` write) reports `false` so the caller serves its
+ * fresh in-memory value instead of a stale payload.
+ */
+export declare function writeRawCookie(key: string, value: string, options?: {
+    domain?: string;
+    maxAgeSeconds?: number;
+}): boolean;
+/** Best-effort delete (must match the domain the cookie was written with). */
+export declare function deleteRawCookie(key: string, domain?: string): void;
+/**
+ * Synchronous two-tier (cookie → in-memory) JSON store. The cookie is the
+ * cross-tab / cross-subdomain source of truth; if writes are blocked (detected
+ * via {@link writeRawCookie}'s read-back) it degrades to a per-page value. The
+ * domain is read lazily per write so it can be resolved after construction.
  */
-export declare function resolveCrossSubdomainValue(cookieStorage: CookieStorage<string>, cookieKey: string, localStorageValue: string | undefined, generateNew: () => string): Promise<string>;
+export declare class SyncJsonCookie<T> {
+    private readonly key;
+    private readonly getDomain;
+    private readonly options;
+    private usable?;
+    private memory?;
+    constructor(key: string, getDomain: () => string, options?: {
+        maxAgeSeconds?: number;
+        /** Validates/normalizes a parsed payload; return undefined to reject it. */
+        validate?: (value: unknown) => T | undefined;
+    });
+    read(): T | undefined;
+    write(value: T): void;
+    clear(): void;
+    private parse;
+}
 export declare function setMarketingCookie(apiKey: string, hostname: string): Promise<void>;

package/dist/types/src/util/debug-recorder.d.ts

@@ -1,3 +1,4 @@
+import type { GlobalScope } from '@amplitude/experiment-core';
 import type { DebugEvent, DebugState, FlagDebugInfo, VEMessengerState, VisualEditorDebugInfo } from '../types/debug';
 /**
  * Provides the non-event, non-timestamp parts of DebugState.
@@ -14,7 +15,7 @@ export declare const DebugRecorder: {
      * Evaluate activation signals. Must be called before any other method.
      * Checks window.__AMP_DEBUG and localStorage('amp-ve-debug').
      */
-    init: (globalScope: typeof globalThis) => void;
+    init: (globalScope: GlobalScope) => void;
     isActive: () => boolean;
     /** Append a debug event. No-op when not active. */
     push: (event: string, detail?: string) => void;

package/dist/types/src/util/shell.d.ts

@@ -1,3 +1,4 @@
+import type { GlobalScope } from '@amplitude/experiment-core';
 export declare const DEVICE_IFRAME_ID = "amp-device-iframe";
 export declare function isMobileModeActive(): boolean;
 /**
@@ -10,13 +11,13 @@ export declare function getDeviceIframe(): HTMLIFrameElement | null;
  * customer site lives inside a same-origin iframe; otherwise it is the
  * top-level document.
  */
-export declare function getCustomerDocument(globalScope: typeof globalThis): Document;
+export declare function getCustomerDocument(globalScope: GlobalScope): Document;
 /**
  * Returns the Window for the customer page. In mobile viewport mode the
  * customer site lives inside a same-origin iframe; otherwise it is the
  * top-level window.
  */
-export declare const getCustomerWindow: (globalScope: typeof globalThis) => Window & typeof globalThis;
+export declare const getCustomerWindow: (globalScope: GlobalScope) => Window & GlobalScope;
 /**
  * Replaces the page DOM with a shell container that loads the customer site
  * in a same-origin iframe.
@@ -32,4 +33,4 @@ export declare const getCustomerWindow: (globalScope: typeof globalThis) => Wind
  * guarantee it renders into the already-built shell rather than racing with
  * DOM restructuring.
  */
-export declare function buildShell(globalScope: typeof globalThis): Promise<void>;
+export declare function buildShell(globalScope: GlobalScope): Promise<void>;

package/dist/types/src/util/when-body-ready.d.ts

@@ -8,5 +8,7 @@
  * In the (effectively impossible) case where `requestAnimationFrame` is
  * unavailable, the callback is invoked immediately rather than never —
  * callers that would crash on a null body should guard inside.
+ *
+ * Returns a cancel function that stops any in-flight body poll.
  */
-export declare const whenBodyReady: (callback: () => void) => void;
+export declare const whenBodyReady: (callback: () => void) => (() => void);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amplitude/experiment-tag",
-  "version": "0.25.1",
+  "version": "0.26.0",
   "description": "Amplitude Experiment Javascript Snippet",
   "author": "Amplitude",
   "homepage": "https://github.com/amplitude/experiment-js-client",
@@ -27,12 +27,14 @@
     "url": "https://github.com/amplitude/experiment-js-client/issues"
   },
   "dependencies": {
+    "@amplitude/analytics-connector": "^1.6.5",
     "@amplitude/analytics-core": "^2.21.0",
     "@amplitude/analytics-types": "^2.11.0",
-    "@amplitude/experiment-core": "^0.13.2",
-    "@amplitude/experiment-js-client": "^1.21.2",
+    "@amplitude/experiment-core": "^0.13.3",
+    "@amplitude/experiment-js-client": "^1.21.3",
     "dom-mutator": "git+ssh://git@github.com/amplitude/dom-mutator#bb5f4b52273e6a3de39dcf6db6f428d66d988a7b",
-    "rollup-plugin-license": "^3.6.0"
+    "rollup-plugin-license": "^3.6.0",
+    "unfetch": "4.1.0"
   },
   "devDependencies": {
     "@rollup/plugin-terser": "^0.4.4",
@@ -43,5 +45,5 @@
   "files": [
     "dist"
   ],
-  "gitHead": "053a2257db0111d8800502b6ef379c65c9dab9a4"
+  "gitHead": "a40490a366c9857c542492137dc7cda04d3be816"
 }