@adobe/alloy 2.29.0-beta.0 → 2.29.0-beta.13

package/libEs6/components/PushNotifications/helpers/getPushSubscriptionDetails.js

@@ -0,0 +1,110 @@
+/*
+Copyright 2025 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+/** @import { PushSubscription } from '../types.js' */
+
+import { base64ToBytes, bytesToBase64 } from "../../../utils/index.js";
+
+/**
+ * Gets push subscription details for the current browser.
+ *
+ * @async
+ * @function
+ *
+ * @param {object} options
+ * @param {string} options.vapidPublicKey - The VAPID public key in base64 format used for push notification authentication.
+ * @param {Window} options.window
+ *
+ * @returns {Promise<PushSubscription>} A promise that resolves to an object containing the push subscription details.
+
+ * @throws {Error} Throws an error if service workers are not supported in the browser.
+ * @throws {Error} Throws an error if user didn't approve push notifications for the domain.
+ * @throws {Error} Throws an error if push notifications are not supported in the browser.
+ * @throws {Error} Throws an error if no VAPID public key was provided.
+ *
+ * @example
+ * // Get subscription details with VAPID key
+ * const vapidKey = "BEl62iUYgUivxIkv69yViEuiBIa40HI5hmjHbKPlXO...";
+ * const subscription = await getPushSubscriptionDetails(vapidKey);
+ * console.log(subscription.endpoint); // "https://fcm.googleapis.com/fcm/send/..."
+ */
+const getPushSubscriptionDetails = async ({
+  vapidPublicKey,
+  window
+}) => {
+  if (!("serviceWorker" in window.navigator)) {
+    throw new Error("Service workers are not supported in this browser.");
+  }
+  if (!("PushManager" in window) || !("Notification" in window)) {
+    throw new Error("Push notifications are not supported in this browser.");
+  }
+
+  /** @type {object} */
+  const notification = window.Notification;
+  if (notification.permission !== "granted") {
+    throw new Error("The user has not given permission to send push notifications.");
+  }
+  const serviceWorkerRegistration =
+  // eslint-disable-next-line compat/compat
+  await window.navigator.serviceWorker.getRegistration();
+  if (!serviceWorkerRegistration) {
+    throw new Error("No service worker registration was found.");
+  }
+
+  // Even `applicationServerKey` is not required in the spec, some browsers like Chrome are requiring it.
+  if (!vapidPublicKey) {
+    throw new Error("No VAPID public key was provided.");
+  }
+  const subscriptionOptions = {
+    userVisibleOnly: true,
+    applicationServerKey: base64ToBytes(vapidPublicKey)
+  };
+
+  // Push subscription handling strategy:
+  //
+  // 1. We always call subscribe() to either get the current subscription or create a new one.
+  //    - If called with the same VAPID key as an existing subscription, it returns that subscription
+  //    - If called with a different VAPID key when a subscription exists, it throws an error
+  //
+  // 2. Error handling approach:
+  //    - Browser error messages vary and don't clearly indicate VAPID key conflicts
+  //    - When subscribe() fails, we assume it's likely due to a VAPID key mismatch
+  //    - We attempt recovery by unsubscribing the existing subscription and retrying
+  //    - If the retry also fails, we re-throw the original error
+  //
+  // This strategy ensures we can handle both new subscriptions and VAPID key changes
+  // while gracefully falling back to error reporting when recovery isn't possible.
+  try {
+    const subscription = await serviceWorkerRegistration.pushManager.subscribe(subscriptionOptions);
+    return {
+      endpoint: subscription.endpoint,
+      keys: {
+        p256dh: bytesToBase64(new Uint8Array(subscription.getKey("p256dh"))),
+        auth: bytesToBase64(new Uint8Array(subscription.getKey("auth")))
+      }
+    };
+  } catch (e) {
+    const subscription = await serviceWorkerRegistration.pushManager.getSubscription();
+    if (!subscription) {
+      throw e;
+    }
+    const unsubscribeResult = await subscription.unsubscribe();
+    if (!unsubscribeResult) {
+      throw e;
+    }
+    return getPushSubscriptionDetails({
+      vapidPublicKey,
+      window
+    });
+  }
+};
+export default getPushSubscriptionDetails;

package/libEs6/components/PushNotifications/index.js

@@ -0,0 +1,93 @@
+/*
+Copyright 2025 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+/** @import { StorageCreator } from '../../utils/types.js' */
+/** @import { EventManager, Logger } from '../../core/types.js' */
+/** @import { IdentityManager } from '../../core/identity/types.js' */
+/** @import { ConsentManager } from '../../core/consent/types.js' */
+/** @import { EdgeRequestExecutor } from '../../core/edgeNetwork/types.js' */
+
+import { objectOf, string } from "../../utils/validation/index.js";
+import { sanitizeOrgIdForCookieName } from "../../utils/index.js";
+import makeSendPushSubscriptionRequest from "./request/makeSendPushSubscriptionRequest.js";
+const isComponentConfigured = ({
+  orgId,
+  pushNotifications: {
+    vapidPublicKey
+  } = {
+    vapidPublicKey: undefined
+  }
+}) => orgId && vapidPublicKey;
+
+/**
+ * @function
+ *
+ * @param {Object} options
+ * @param {{ orgId: string, pushNotifications: { vapidPublicKey: string }}} options.config
+ * @param {StorageCreator} options.createNamespacedStorage
+ * @param {EventManager} options.eventManager
+ * @param {Logger} options.logger
+ * @param {ConsentManager} options.consent
+ * @param {IdentityManager} options.identity
+ * @param {EdgeRequestExecutor} options.sendEdgeNetworkRequest
+ * @returns {{  commands: { sendPushSubscription: object } }}
+ */
+const createPushNotifications = ({
+  createNamespacedStorage,
+  eventManager,
+  config,
+  logger,
+  consent,
+  identity,
+  sendEdgeNetworkRequest
+}) => {
+  return {
+    commands: {
+      sendPushSubscription: {
+        run: async () => {
+          if (!isComponentConfigured(config)) {
+            throw new Error("Push notifications module is not configured. No VAPID public key was provided.");
+          }
+          const {
+            orgId,
+            pushNotifications: {
+              vapidPublicKey
+            } = {
+              vapidPublicKey: undefined
+            }
+          } = config || {};
+          const storage = createNamespacedStorage(`${sanitizeOrgIdForCookieName(orgId)}.pushNotifications.`);
+          return makeSendPushSubscriptionRequest({
+            config: {
+              vapidPublicKey
+            },
+            storage: storage.persistent,
+            logger,
+            sendEdgeNetworkRequest,
+            consent,
+            eventManager,
+            identity,
+            window
+          });
+        },
+        optionsValidator: objectOf({}).noUnknownFields()
+      }
+    }
+  };
+};
+createPushNotifications.namespace = "Push Notifications";
+createPushNotifications.configValidators = objectOf({
+  pushNotifications: objectOf({
+    vapidPublicKey: string().required()
+  }).noUnknownFields()
+});
+export default createPushNotifications;

package/libEs6/components/PushNotifications/request/createSendPushSubscriptionPayload.js

@@ -0,0 +1,61 @@
+/*
+Copyright 2025 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+/** @import { EventManager } from "../../../core/types.js" */
+/** @import { DataCollectionRequestPayload } from "../../../utils/request/types.js" */
+
+import createDataCollectionRequestPayload from "../../../utils/request/createDataCollectionRequestPayload.js";
+
+/**
+ * Creates a data collection request payload for sending push subscription details to Adobe Experience Platform.
+ *
+ * This function constructs an event containing push notification subscription information,
+ * including the subscription details, platform information, and identity data. The event
+ * is then packaged into a data collection request payload for transmission to the edge network.
+ *
+ * @async
+ * @function
+ *
+ * @param {Object} options
+ * @param {string} options.ecid
+ * @param {EventManager} options.eventManager
+ * @param {string} options.serializedPushSubscriptionDetails
+ * @param {Window} options.window
+ *
+ * @returns {Promise<DataCollectionRequestPayload>}
+ */
+export default async ({
+  ecid,
+  eventManager,
+  serializedPushSubscriptionDetails,
+  window
+}) => {
+  const event = eventManager.createEvent();
+  event.setUserData({
+    pushNotificationDetails: [{
+      appID: window.location.host,
+      token: serializedPushSubscriptionDetails,
+      platform: "web",
+      denylisted: false,
+      identity: {
+        namespace: {
+          code: "ECID"
+        },
+        id: ecid
+      }
+    }]
+  });
+  event.finalize();
+  const payload = createDataCollectionRequestPayload();
+  payload.addEvent(event);
+  return payload;
+};

package/libEs6/components/PushNotifications/request/createSendPushSubscriptionRequest.js

@@ -0,0 +1,34 @@
+/*
+Copyright 2023 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+/** @import { DataCollectionRequestPayload, Request } from '../../../utils/request/types.js' */
+
+import { createRequest } from "../../../utils/request/index.js";
+
+/**
+ * @function
+ *
+ * @param {{ payload: DataCollectionRequestPayload }} options
+ *
+ * @returns {Request}
+ */
+export default ({
+  payload
+}) => createRequest({
+  payload,
+  getAction() {
+    return "interact";
+  },
+  getUseSendBeacon() {
+    return false;
+  }
+});

package/libEs6/components/PushNotifications/request/makeSendPushSubscriptionRequest.js

@@ -0,0 +1,84 @@
+/*
+Copyright 2025 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+/** @import { Storage } from '../../../utils/types.js' */
+/** @import { EventManager, Logger } from '../../../core/types.js' */
+/** @import { IdentityManager } from '../../../core/identity/types.js' */
+/** @import { ConsentManager } from '../../../core/consent/types.js' */
+/** @import { EdgeRequestExecutor } from '../../../core/edgeNetwork/types.js' */
+
+import { sortObjectKeysRecursively } from "../../../utils/index.js";
+import getPushSubscriptionDetails from "../helpers/getPushSubscriptionDetails.js";
+import createSendPushSubscriptionRequest from "./createSendPushSubscriptionRequest.js";
+import createSendPushSubscriptionPayload from "./createSendPushSubscriptionPayload.js";
+const SUBSCRIPTION_DETAILS = "subscriptionDetails";
+
+/**
+ * Retrieves and returns push subscription details with sorted object keys.
+ *
+ * This function gets the push subscription details using the provided VAPID public key
+ * and returns the details with all object keys sorted recursively for consistent output.
+ *
+ * @async
+ * @function
+ *
+ * @param {Object} options
+ * @param {{vapidPublicKey: string}} options.config
+ * @param {Storage} options.storage
+ * @param {Logger} options.logger
+ * @param {EventManager} options.eventManager
+ * @param {IdentityManager} options.identity
+ * @param {EdgeRequestExecutor} options.sendEdgeNetworkRequest
+ * @param {ConsentManager} options.consent
+ * @param {Window} options.window
+ *
+ * @returns {Promise<void>}
+ */
+export default async ({
+  config: {
+    vapidPublicKey
+  },
+  storage,
+  logger,
+  sendEdgeNetworkRequest,
+  consent,
+  eventManager,
+  identity,
+  window
+}) => {
+  await identity.awaitIdentity();
+  const ecid = identity.getEcidFromCookie();
+  const pushSubscriptionDetails = await getPushSubscriptionDetails({
+    vapidPublicKey,
+    window
+  });
+  const serializedPushSubscriptionDetails = JSON.stringify(sortObjectKeysRecursively(pushSubscriptionDetails));
+  const cacheValue = `${ecid}${serializedPushSubscriptionDetails}`;
+  if (cacheValue === storage.getItem(SUBSCRIPTION_DETAILS)) {
+    logger.info("Subscription details have not changed. Not sending to the server.");
+    return;
+  }
+  storage.setItem(SUBSCRIPTION_DETAILS, cacheValue);
+  const payload = await createSendPushSubscriptionPayload({
+    eventManager,
+    ecid,
+    serializedPushSubscriptionDetails,
+    window
+  });
+  const request = createSendPushSubscriptionRequest({
+    payload
+  });
+  await consent.awaitConsent();
+  await sendEdgeNetworkRequest({
+    request
+  });
+};

package/libEs6/components/PushNotifications/types.js

@@ -0,0 +1,11 @@
+/** @import { Identity } from '../../utils/request/types.js' */
+
+/**
+ * @typedef {Object} PushSubscription
+ * @property {string} endpoint - The push service endpoint URL
+ * @property {Object} keys - The subscription keys object
+ * @property {string|null} keys.p256dh - The P-256 ECDH public key as an ArrayBuffer, or null if not available
+ * @property {string|null} keys.auth - The authentication secret as an ArrayBuffer, or null if not available
+ */
+
+export const Types = {};

package/libEs6/constants/libraryVersion.js

@@ -13,4 +13,4 @@ governing permissions and limitations under the License.
 // The __VERSION__ keyword will be replace at alloy build time with the package.json version.
 // see babel-plugin-version
 
-export default "2.29.0-beta.0";
+export default "2.29.0-beta.13";

package/libEs6/core/componentCreators.js

@@ -22,4 +22,5 @@ export { default as mediaAnalyticsBridge } from "../components/MediaAnalyticsBri
 export { default as personalization } from "../components/Personalization/index.js";
 export { default as rulesEngine } from "../components/RulesEngine/index.js";
 export { default as streamingMedia } from "../components/StreamingMedia/index.js";
-export { default as advertising } from "../components/Advertising/index.js";
+export { default as advertising } from "../components/Advertising/index.js";
+export { default as pushNotifications } from "../components/PushNotifications/index.js";

package/libEs6/core/consent/createConsent.js

@@ -10,9 +10,21 @@ OF ANY KIND, either express or implied. See the License for the specific languag
 governing permissions and limitations under the License.
 */
 
+/** @import { ConsentManager } from './types.js' */
+
 import { IN, OUT, PENDING } from "../../constants/consentStatus.js";
 import { GENERAL } from "../../constants/consentPurpose.js";
 import { CONSENT_SOURCE_DEFAULT, CONSENT_SOURCE_INITIAL, CONSENT_SOURCE_NEW } from "./createConsentStateMachine.js";
+
+/**
+ * @function
+ *
+ * @param {Object} options
+ * @param {ConsentStateMachine} options.generalConsentState
+ * @param {Logger} options.logger
+ *
+ * @returns {ConsentManager}
+ */
 export default ({
   generalConsentState,
   logger

package/libEs6/core/consent/createConsentStateMachine.js

@@ -10,18 +10,54 @@ OF ANY KIND, either express or implied. See the License for the specific languag
 governing permissions and limitations under the License.
 */
 
+/** @import { Logger } from '../../core/types.js' */
+/** @import { ConsentStateMachineUtils, ConsentStateMachine } from './types.js' */
+
 import { defer } from "../../utils/index.js";
 export const DECLINED_CONSENT = "The user declined consent.";
 export const DECLINED_CONSENT_ERROR_CODE = "declinedConsent";
 export const CONSENT_SOURCE_DEFAULT = "default";
 export const CONSENT_SOURCE_INITIAL = "initial";
 export const CONSENT_SOURCE_NEW = "new";
+
+/**
+ * @private
+ * @param {string} errorMessage
+ * @returns {Error}
+ */
 const createDeclinedConsentError = errorMessage => {
   const error = new Error(errorMessage);
   error.code = DECLINED_CONSENT_ERROR_CODE;
   error.message = errorMessage;
   return error;
 };
+
+/**
+ * Creates a consent state machine that manages user consent preferences and
+ * coordinates deferred operations that require consent.
+ *
+ * The state machine supports the following states:
+ * - "in": User has provided consent (with default or explicit consent)
+ * - "out": User has declined consent (with default or explicit decline)
+ * - "pending": Consent decision is awaiting user input
+ *
+ * @param {object} options
+ * @param {Logger} options.logger
+ *
+ * @returns {ConsentStateMachine}
+ *
+ * @example
+ * const consentStateMachine = createConsentStateMachine({ logger });
+ *
+ * // Set consent state
+ * consentStateMachine.in('new');
+ *
+ * // Wait for consent
+ * await consentStateMachine.awaitConsent();
+ *
+ * // Check current state
+ * const { state, wasSet } = consentStateMachine.current();
+ */
 export default ({
   logger
 }) => {

package/libEs6/core/consent/types.js

@@ -0,0 +1,21 @@
+/**
+ * @typedef {Object} ConsentStateMachine
+ * @property {function(string): void} in
+ * @property {function(string): void} out
+ * @property {function(string): void} pending
+ * @property {function(boolean=): Promise<void>} awaitConsent
+ * @property {function(): Promise<void>} withConsent
+ * @property {function(): {state: string, wasSet: boolean}} current
+ */
+
+/**
+ * @typedef {Object} ConsentManager
+ * @property {function(Object, Object): void} initializeConsent
+ * @property {function(Object): void} setConsent
+ * @property {function(): void} suspend
+ * @property {function(): Promise<void>} awaitConsent
+ * @property {function(): Promise<void>} withConsent
+ * @property {function(): {state: string, wasSet: boolean}} current
+ */
+
+export const Types = {};

package/libEs6/core/edgeNetwork/injectSendEdgeNetworkRequest.js

@@ -10,6 +10,9 @@ OF ANY KIND, either express or implied. See the License for the specific languag
 governing permissions and limitations under the License.
 */
 
+/** @import { EdgeRequestExecutor } from './types.js' */
+/** @import { ResponseCreator } from '../types.js' */
+
 import { ID_THIRD_PARTY as ID_THIRD_PARTY_DOMAIN } from "../../constants/domain.js";
 import apiVersion from "../../constants/apiVersion.js";
 import { createCallbackAggregator, noop } from "../../utils/index.js";
@@ -19,6 +22,23 @@ import handleRequestFailure from "./handleRequestFailure.js";
 const isDemdexBlockedError = (error, request) => {
   return request.getUseIdThirdPartyDomain() && isNetworkError(error);
 };
+
+/**
+ * @function
+ *
+ * @param {object} options
+ * @param {{edgeDomain: string, edgeBasePath: string, datastreamId: string}} options.config
+ * @param {object} options.lifecycle
+ * @param {object} options.cookieTransfer
+ * @param {function(object): Promise<Object>} options.sendNetworkRequest
+ * @param {ResponseCreator} options.createResponse
+ * @param {function(object): void} options.processWarningsAndErrors
+ * @param {function(): string|undefined} options.getLocationHint
+ * @param {function(): string} options.getAssuranceValidationTokenParams
+
+ *
+ * @returns {EdgeRequestExecutor} A function that sends edge network requests with lifecycle management
+ */
 export default ({
   config,
   lifecycle,

package/libEs6/core/edgeNetwork/types.js

@@ -0,0 +1,7 @@
+/** @import { Request } from '../../utils/request/types.js' */
+
+/**
+ * @typedef {function({request: Request, runOnResponseCallbacks?: function(): void, runOnRequestFailureCallbacks?: function(): void}): Promise<Object>} EdgeRequestExecutor
+ */
+
+export const Types = {};

package/libEs6/core/identity/createIdentity.js

@@ -0,0 +1,81 @@
+/*
+Copyright 2025 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+/** @import { IdentityManager } from './types.js' */
+/** @import { Logger } from '../types.js' */
+/** @import { CookieJar } from '../../utils/types.js' */
+
+import createDecodeKndctrCookie from "../../utils/createDecodeKndctrCookie.js";
+
+/**
+ * Creates an identity management service for handling ECID (Experience Cloud ID) resolution and tracking.
+ *
+ * This factory function creates an identity manager service that manages the state of identity resolution,
+ * provides methods to check for existing identity cookies, and handles the asynchronous nature
+ * of identity acquisition in Adobe Experience Platform Web SDK.
+ *
+ * @function
+ *
+ * @param {Object} options
+ * @param {Logger} options.logger
+ * @param {CookieJar} options.loggingCookieJar
+ * @param {{orgId: string}} options.config
+ *
+ * @returns {IdentityManager}
+ *
+ * @example
+ * // Create an identity service
+ * const identityManager = createIdentity({
+ *   logger: myLogger,
+ *   loggingCookieJar: myCookieJar,
+ *   config: { orgId: 'myOrgId@AdobeOrg' }
+ * });
+ *
+ * // Initialize and check for existing identity
+ * identityManager.initialize();
+ *
+ * // Wait for identity to be available
+ * await identityManager.awaitIdentity();
+ *
+ * // Get ECID from cookie
+ * const ecid = identityManager.getEcidFromCookie();
+ */
+export default ({
+  logger,
+  loggingCookieJar,
+  config
+}) => {
+  let awaitIdentityResolve = null;
+  const awaitIdentityPromise = new Promise(resolve => {
+    awaitIdentityResolve = resolve;
+  });
+  const decodeKndctrCookie = createDecodeKndctrCookie({
+    orgId: config.orgId,
+    cookieJar: loggingCookieJar,
+    logger
+  });
+  return {
+    initialize() {
+      const ecidFromCookie = decodeKndctrCookie();
+      if (ecidFromCookie) {
+        this.setIdentityAcquired();
+      }
+    },
+    setIdentityAcquired() {
+      awaitIdentityResolve();
+    },
+    awaitIdentity() {
+      return awaitIdentityPromise;
+    },
+    getEcidFromCookie: () => decodeKndctrCookie()
+  };
+};

package/libEs6/core/identity/types.js

@@ -0,0 +1,12 @@
+/** @import { Logger } from '../../core/types.js' */
+/** @import { CookieJar } from '../../utils/types.js' */
+
+/**
+ * @typedef {Object} IdentityManager
+ * @property {Function} initialize
+ * @property {Function} setIdentityAcquired - Marks identity as acquired and resolves any pending identity promises
+ * @property {Function} awaitIdentity - Returns a promise that resolves when identity is acquired
+ * @property {Function} getEcidFromCookie
+ */
+
+export const Types = {};

package/libEs6/core/index.js

@@ -17,6 +17,7 @@ import createLifecycle from "./createLifecycle.js";
 import createComponentRegistry from "./createComponentRegistry.js";
 import injectSendNetworkRequest from "./network/injectSendNetworkRequest.js";
 import injectExtractEdgeInfo from "./edgeNetwork/injectExtractEdgeInfo.js";
+import createIdentity from "./identity/createIdentity.js";
 import createConsent from "./consent/createConsent.js";
 import createConsentStateMachine from "./consent/createConsentStateMachine.js";
 import createEvent from "./createEvent.js";
@@ -156,6 +157,12 @@ export const createExecuteCommand = ({
       generalConsentState,
       logger
     });
+    const identity = createIdentity({
+      config,
+      logger,
+      loggingCookieJar
+    });
+    identity.initialize();
     const eventManager = createEventManager({
       config,
       logger,
@@ -177,6 +184,7 @@ export const createExecuteCommand = ({
           config,
           componentRegistry,
           consent,
+          identity,
           eventManager,
           fireReferrerHideableImage,
           logger: componentLogger,