@adobe/alloy 2.34.0-beta.0 → 2.34.0-beta.2

package/dist/types/browser/src/services/createBrowserCookieService.d.ts

@@ -0,0 +1,15 @@
+export default createBrowserCookieService;
+/**
+ * The optional `jar` parameter is the recursion seam for `withConverter` —
+ * every converted js-cookie instance must itself satisfy `CookieService`.
+ *
+ * @param {{ get: Function, set: Function, remove: Function, withConverter: Function }} [jar]
+ * @returns {CookieService}
+ */
+declare function createBrowserCookieService(jar?: {
+    get: Function;
+    set: Function;
+    remove: Function;
+    withConverter: Function;
+}): CookieService;
+import type { CookieService } from "@adobe/alloy-core/services";

package/dist/types/browser/src/services/createBrowserGlobalsService.d.ts

@@ -0,0 +1,5 @@
+export default createBrowserGlobalsService;
+/** @import { GlobalsService } from "@adobe/alloy-core/services" */
+/** @returns {GlobalsService} */
+declare function createBrowserGlobalsService(): GlobalsService;
+import type { GlobalsService } from "@adobe/alloy-core/services";

package/dist/types/browser/src/services/createBrowserLegacyService.d.ts

@@ -0,0 +1,4 @@
+export default createBrowserLegacyService;
+/** @returns {LegacyService} */
+declare function createBrowserLegacyService(): LegacyService;
+import type { LegacyService } from "@adobe/alloy-core/services";

package/dist/types/browser/src/services/createBrowserNetworkService.d.ts

@@ -0,0 +1,9 @@
+export default createBrowserNetworkService;
+/**
+ * @param {{ logger: import('@adobe/alloy-core/core/types.js').Logger }} dependencies
+ * @returns {NetworkService}
+ */
+declare function createBrowserNetworkService({ logger }: {
+    logger: import("@adobe/alloy-core/core/types.js").Logger;
+}): NetworkService;
+import type { NetworkService } from "@adobe/alloy-core/services";

package/dist/types/browser/src/services/createBrowserPlatformServices.d.ts

@@ -0,0 +1,9 @@
+export default createBrowserPlatformServices;
+/**
+ * @param {{ logger: import('@adobe/alloy-core/core/types.js').Logger }} dependencies
+ * @returns {PlatformServices}
+ */
+declare function createBrowserPlatformServices({ logger }: {
+    logger: import("@adobe/alloy-core/core/types.js").Logger;
+}): PlatformServices;
+import type { PlatformServices } from "@adobe/alloy-core/services";

package/dist/types/browser/src/services/createBrowserRuntimeService.d.ts

@@ -0,0 +1,5 @@
+export default createBrowserRuntimeService;
+/** @import { RuntimeService } from "@adobe/alloy-core/services" */
+/** @returns {RuntimeService} */
+declare function createBrowserRuntimeService(): RuntimeService;
+import type { RuntimeService } from "@adobe/alloy-core/services";

package/dist/types/browser/src/services/createBrowserStorageService.d.ts

@@ -0,0 +1,4 @@
+export default createBrowserStorageService;
+/** @returns {StorageService} */
+declare function createBrowserStorageService(): StorageService;
+import type { StorageService } from "@adobe/alloy-core/services";

package/dist/types/browser/src/services/index.d.ts

@@ -0,0 +1,7 @@
+export { default as createBrowserNetworkService } from "./createBrowserNetworkService.js";
+export { default as createBrowserStorageService } from "./createBrowserStorageService.js";
+export { default as createBrowserCookieService } from "./createBrowserCookieService.js";
+export { default as createBrowserRuntimeService } from "./createBrowserRuntimeService.js";
+export { default as createBrowserLegacyService } from "./createBrowserLegacyService.js";
+export { default as createBrowserGlobalsService } from "./createBrowserGlobalsService.js";
+export { default as createBrowserPlatformServices } from "./createBrowserPlatformServices.js";

package/dist/types/core/src/components/BrandConcierge/createBuildEndpointUrl.d.ts

@@ -1,8 +1,7 @@
 declare function _default({ queryString }: {
     queryString: any;
-}): ({ edgeDomain, region, request, datastreamId }: {
+}): ({ edgeDomain, request, datastreamId }: {
     edgeDomain: any;
-    region: any;
     request: any;
     datastreamId: any;
 }) => string;

package/dist/types/core/src/components/BrandConcierge/createConversationServiceRequest.d.ts

@@ -1,7 +1,8 @@
-declare function _default({ payload, action, sessionId, voiceEnabled, }: {
+declare function _default({ payload, action, sessionId, voiceEnabled, region, }: {
     payload: any;
     action?: string | undefined;
     sessionId: any;
     voiceEnabled?: boolean | undefined;
+    region: any;
 }): import("../../utils/request/types.js").Request;
 export default _default;

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

@@ -1,6 +1,5 @@
-declare function _default({ console, locationSearch, createLogger, instanceName, createNamespacedStorage, getMonitors, }: {
+declare function _default({ console, createLogger, instanceName, createNamespacedStorage, getMonitors, }: {
     console: any;
-    locationSearch: any;
     createLogger: any;
     instanceName: any;
     createNamespacedStorage: any;

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

@@ -1,13 +1,8 @@
-export function createExecuteCommand({ instanceName, logController: { setDebugEnabled, logger, createComponentLogger }, components, }: {
-    instanceName: any;
-    logController: {
-        setDebugEnabled: any;
-        logger: any;
-        createComponentLogger: any;
-    };
-    components: any;
+export function createExecuteCommand({ instanceName, monitors, components, createPlatformServices, }: {
+    instanceName: string;
+    monitors?: import("./types.js").AlloyMonitor[] | undefined;
+    components: Array<Function>;
+    createPlatformServices: (deps: {
+        logger: import("./types.js").Logger;
+    }) => import("../services/index.js").PlatformServices;
 }): (commandName: any, options?: {}) => Promise<any>;
-declare function _default({ components }: {
-    components: any;
-}): void;
-export default _default;

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

@@ -2,8 +2,13 @@ export function createCustomInstance(options?: {
     name?: string | undefined;
     monitors?: import("./core/types.js").AlloyMonitor[] | undefined;
     components?: Function[] | undefined;
-}): (commandName: string, options?: Object) => Promise<any>;
+}, createPlatformServices?: CreatePlatformServices): (commandName: string, options?: Object) => Promise<any>;
 export function createInstance(options?: {
     name?: string | undefined;
     monitors?: import("./core/types.js").AlloyMonitor[] | undefined;
-}): (commandName: string, options?: Object) => Promise<any>;
+}, createPlatformServices?: CreatePlatformServices): (commandName: string, options?: Object) => Promise<any>;
+export type CreatePlatformServices = (deps: {
+    logger: Logger;
+}) => PlatformServices;
+import type { Logger } from './core/types.js';
+import type { PlatformServices } from './services/index.js';

package/dist/types/core/src/services/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @typedef {import("./types.js").NetworkResponse} NetworkResponse
+ * @typedef {import("./types.js").NetworkService} NetworkService
+ * @typedef {import("./types.js").Storage} Storage
+ * @typedef {import("./types.js").NamespacedStorage} NamespacedStorage
+ * @typedef {import("./types.js").StorageService} StorageService
+ * @typedef {import("./types.js").CookieAttributes} CookieAttributes
+ * @typedef {import("./types.js").CookieConverter} CookieConverter
+ * @typedef {import("./types.js").CookieService} CookieService
+ * @typedef {import("./types.js").RuntimeService} RuntimeService
+ * @typedef {import("./types.js").LegacyService} LegacyService
+ * @typedef {import("./types.js").GlobalsService} GlobalsService
+ * @typedef {import("./types.js").PlatformServices} PlatformServices
+ */
+export const Services: {};
+export type NetworkResponse = import("./types.js").NetworkResponse;
+export type NetworkService = import("./types.js").NetworkService;
+export type Storage = import("./types.js").Storage;
+export type NamespacedStorage = import("./types.js").NamespacedStorage;
+export type StorageService = import("./types.js").StorageService;
+export type CookieAttributes = import("./types.js").CookieAttributes;
+export type CookieConverter = import("./types.js").CookieConverter;
+export type CookieService = import("./types.js").CookieService;
+export type RuntimeService = import("./types.js").RuntimeService;
+export type LegacyService = import("./types.js").LegacyService;
+export type GlobalsService = import("./types.js").GlobalsService;
+export type PlatformServices = import("./types.js").PlatformServices;

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

@@ -0,0 +1,91 @@
+export type NetworkResponse = {
+    statusCode: number;
+    body: string;
+    getHeader: (name: string) => (string | null);
+};
+export type SendFetchRequest = (url: string, body: string) => Promise<NetworkResponse>;
+export type SendBeaconRequest = (url: string, body: string) => Promise<NetworkResponse>;
+export type NetworkService = {
+    /**
+     *   Must send cookies (`credentials: "include"` in browsers).
+     */
+    sendFetchRequest: SendFetchRequest;
+    /**
+     *   May fall back to `sendFetchRequest` when the underlying transport is
+     *   unavailable.
+     */
+    sendBeaconRequest: SendBeaconRequest;
+};
+export type Storage = {
+    getItem: (name: string) => Promise<string | null>;
+    setItem: (name: string, value: string) => Promise<boolean>;
+    removeItem: (name: string) => Promise<boolean>;
+    clear: () => Promise<boolean>;
+};
+export type NamespacedStorage = {
+    session: Storage;
+    persistent: Storage;
+};
+export type StorageService = {
+    createNamespacedStorage: (namespace: string) => NamespacedStorage;
+};
+export type CookieAttributes = {
+    domain?: string | undefined;
+    path?: string | undefined;
+    expires?: number | Date | undefined;
+    secure?: boolean | undefined;
+    sameSite?: "strict" | "lax" | "none" | undefined;
+};
+export type CookieConverter = {
+    read?: ((value: string, name: string) => string) | undefined;
+    write?: ((value: string, name: string) => string) | undefined;
+};
+export type CookieService = {
+    get: (name: string) => (string | undefined);
+    set: (name: string, value: string, options?: CookieAttributes) => (string | undefined);
+    remove: (name: string, options?: CookieAttributes) => void;
+    withConverter: (converter: CookieConverter) => CookieService;
+};
+export type RuntimeService = {
+    setTimeout: (handler: Function, timeout?: number, ...args: any[]) => any;
+    clearTimeout: (id: any) => void;
+    atob: (data: string) => string;
+    btoa: (data: string) => string;
+    TextEncoder: typeof TextEncoder;
+    TextDecoder: typeof TextDecoder;
+    /**
+     *   Epoch-millisecond timestamp.
+     */
+    now: () => number;
+};
+/**
+ * Bridge to legacy Adobe libraries (Visitor.js, `adobe.optIn`).
+ */
+export type LegacyService = {
+    getEcidFromVisitor: (params: {
+        orgId: string;
+        logger: import("../core/types.js").Logger;
+    }) => Promise<string | undefined>;
+    /**
+     *   Resolves immediately when no legacy opt-in object is present.
+     */
+    awaitVisitorOptIn: (params: {
+        logger: import("../core/types.js").Logger;
+    }) => Promise<void>;
+};
+export type GlobalsService = {
+    getInstanceNames: () => string[];
+    getInstanceQueue: (instanceName: string) => any[];
+    getMonitors: () => import("../core/types.js").AlloyMonitor[];
+    getLocationSearch: () => string;
+    getUserAgent: () => string;
+    getHostname: () => string;
+};
+export type PlatformServices = {
+    network: NetworkService;
+    storage: StorageService;
+    cookie: CookieService;
+    runtime: RuntimeService;
+    legacy: LegacyService;
+    globals: GlobalsService;
+};

package/dist/types/core/src/utils/getApexDomain.d.ts

@@ -1,2 +1,2 @@
-declare function _default(window: Object, cookieJar: Object): string;
+declare function _default(hostname: string, cookieJar: Object): string;
 export default _default;

package/dist/types/core/src/utils/request/createGetAssuranceValidationTokenParams.d.ts

@@ -1,5 +1,5 @@
-declare function _default({ window, createNamespacedStorage }: {
-    window: any;
+declare function _default({ getLocationSearch, createNamespacedStorage }: {
+    getLocationSearch: any;
     createNamespacedStorage: any;
 }): () => string;
 export default _default;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adobe/alloy",
-  "version": "2.34.0-beta.0",
+  "version": "2.34.0-beta.2",
   "description": "Adobe Experience Platform Web SDK",
   "type": "module",
   "repository": {
@@ -68,7 +68,7 @@
     "commander": "^14.0.2",
     "rollup": "^4.60.3",
     "rollup-plugin-license": "^3.7.1",
-    "@adobe/alloy-core": "^1.2.0-beta.0"
+    "@adobe/alloy-core": "^1.2.0-beta.2"
   },
   "devDependencies": {
     "glob": "^13.0.6",

package/src/index.js

@@ -12,12 +12,16 @@ governing permissions and limitations under the License.
 import { createCustomInstance as createCoreCustomInstance } from "@adobe/alloy-core";
 import * as allOptionalComponents from "./allOptionalComponents.js";
 import * as allRequiredComponents from "./components/requiredComponentCreators.js";
+import createBrowserPlatformServices from "./services/createBrowserPlatformServices.js";
 
 export const createCustomInstance = ({ components = [], ...options } = {}) =>
-  createCoreCustomInstance({
-    ...options,
-    components: [...Object.values(allRequiredComponents), ...components],
-  });
+  createCoreCustomInstance(
+    {
+      ...options,
+      components: [...Object.values(allRequiredComponents), ...components],
+    },
+    createBrowserPlatformServices,
+  );
 
 export const createInstance = (options = {}) =>
   createCustomInstance({

package/src/services/createBrowserCookieService.js

@@ -0,0 +1,34 @@
+/*
+Copyright 2026 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 { CookieService } from "@adobe/alloy-core/services" */
+
+import cookieJar from "@adobe/alloy-core/utils/cookieJar.js";
+
+/**
+ * The optional `jar` parameter is the recursion seam for `withConverter` —
+ * every converted js-cookie instance must itself satisfy `CookieService`.
+ *
+ * @param {{ get: Function, set: Function, remove: Function, withConverter: Function }} [jar]
+ * @returns {CookieService}
+ */
+const createBrowserCookieService = (jar = cookieJar) => ({
+  get: (name) => jar.get(name),
+  set: (name, value, options) => jar.set(name, value, options),
+  remove: (name, options) => {
+    jar.remove(name, options);
+  },
+  withConverter: (converter) =>
+    createBrowserCookieService(jar.withConverter(converter)),
+});
+
+export default createBrowserCookieService;

package/src/services/createBrowserGlobalsService.js

@@ -0,0 +1,30 @@
+/*
+Copyright 2026 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.
+*/
+
+/* eslint-disable dot-notation */
+
+/** @import { GlobalsService } from "@adobe/alloy-core/services" */
+
+/** @returns {GlobalsService} */
+const createBrowserGlobalsService = () => ({
+  getInstanceNames: () => window["__alloyNS"] || [],
+  getInstanceQueue: (instanceName) => {
+    const namespace = window[instanceName];
+    return (namespace && namespace.q) || [];
+  },
+  getMonitors: () => window["__alloyMonitors"] || [],
+  getLocationSearch: () => window.location.search,
+  getUserAgent: () => window.navigator.userAgent,
+  getHostname: () => window.location.hostname,
+});
+
+export default createBrowserGlobalsService;

package/src/services/createBrowserLegacyService.js

@@ -0,0 +1,91 @@
+/*
+Copyright 2026 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 { LegacyService } from "@adobe/alloy-core/services" */
+
+import { isFunction, isObject } from "@adobe/alloy-core/utils/index.js";
+
+const getVisitor = () => {
+  const { Visitor } = window;
+  return isFunction(Visitor) && isFunction(Visitor.getInstance) && Visitor;
+};
+
+/**
+ * @param {{ logger: import('@adobe/alloy-core/core/types.js').Logger }} params
+ * @returns {Promise<void>}
+ */
+const awaitVisitorOptIn = ({ logger }) =>
+  new Promise((resolve, reject) => {
+    if (isObject(window.adobe) && isObject(window.adobe.optIn)) {
+      const optInOld = window.adobe.optIn;
+      logger.info(
+        "Delaying request while waiting for legacy opt-in to let Visitor retrieve ECID from server.",
+      );
+      optInOld.fetchPermissions(() => {
+        if (optInOld.isApproved([optInOld.Categories.ECID])) {
+          logger.info(
+            "Received legacy opt-in approval to let Visitor retrieve ECID from server.",
+          );
+          resolve();
+        } else {
+          reject(new Error("Legacy opt-in was declined."));
+        }
+      }, true);
+    } else {
+      resolve();
+    }
+  });
+
+/**
+ * @param {{ orgId: string, logger: import('@adobe/alloy-core/core/types.js').Logger }} params
+ * @returns {Promise<string | undefined>}
+ */
+const getEcidFromVisitor = async ({ orgId, logger }) => {
+  const Visitor = getVisitor();
+  if (!Visitor) {
+    return undefined;
+  }
+  try {
+    await awaitVisitorOptIn({ logger });
+    logger.info(
+      "Delaying request while using Visitor to retrieve ECID from server.",
+    );
+    return await new Promise((resolve) => {
+      const visitor = Visitor.getInstance(orgId, {});
+      visitor.getMarketingCloudVisitorID((ecid) => {
+        logger.info(
+          "Resuming previously delayed request that was waiting for ECID from Visitor.",
+        );
+        resolve(ecid);
+      }, true);
+    });
+  } catch (error) {
+    // If consent was denied, fall back to retrieving the ECID from the
+    // experience edge. OptIn and AEP Web SDK consent should operate
+    // independently, but during ID migration AEP Web SDK needs to wait for
+    // optIn so that only one ECID is generated.
+    if (error) {
+      logger.info(`${error.message}, retrieving ECID from experience edge`);
+    } else {
+      logger.info("An error occurred while obtaining the ECID from Visitor.");
+    }
+    return undefined;
+  }
+};
+
+/** @returns {LegacyService} */
+const createBrowserLegacyService = () => ({
+  getEcidFromVisitor,
+  awaitVisitorOptIn,
+});
+
+export default createBrowserLegacyService;

package/src/services/createBrowserNetworkService.js

@@ -0,0 +1,41 @@
+/*
+Copyright 2026 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 { NetworkService } from "@adobe/alloy-core/services" */
+
+import injectSendFetchRequest from "@adobe/alloy-core/core/network/requestMethods/injectSendFetchRequest.js";
+import injectSendBeaconRequest from "@adobe/alloy-core/core/network/requestMethods/injectSendBeaconRequest.js";
+
+/**
+ * @param {{ logger: import('@adobe/alloy-core/core/types.js').Logger }} dependencies
+ * @returns {NetworkService}
+ */
+const createBrowserNetworkService = ({ logger }) => {
+  const { fetch, navigator } = window;
+  const sendFetchRequest = injectSendFetchRequest({ fetch });
+  const sendBeaconRequest =
+    typeof navigator.sendBeacon === "function"
+      ? injectSendBeaconRequest({
+          // bind() avoids "illegal invocation" when sendBeacon loses its receiver.
+          sendBeacon: navigator.sendBeacon.bind(navigator),
+          sendFetchRequest,
+          logger,
+        })
+      : sendFetchRequest;
+
+  return {
+    sendFetchRequest,
+    sendBeaconRequest,
+  };
+};
+
+export default createBrowserNetworkService;

package/src/services/createBrowserPlatformServices.js

@@ -0,0 +1,35 @@
+/*
+Copyright 2026 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 { PlatformServices } from "@adobe/alloy-core/services" */
+
+import createBrowserNetworkService from "./createBrowserNetworkService.js";
+import createBrowserStorageService from "./createBrowserStorageService.js";
+import createBrowserCookieService from "./createBrowserCookieService.js";
+import createBrowserRuntimeService from "./createBrowserRuntimeService.js";
+import createBrowserLegacyService from "./createBrowserLegacyService.js";
+import createBrowserGlobalsService from "./createBrowserGlobalsService.js";
+
+/**
+ * @param {{ logger: import('@adobe/alloy-core/core/types.js').Logger }} dependencies
+ * @returns {PlatformServices}
+ */
+const createBrowserPlatformServices = ({ logger }) => ({
+  network: createBrowserNetworkService({ logger }),
+  storage: createBrowserStorageService(),
+  cookie: createBrowserCookieService(),
+  runtime: createBrowserRuntimeService(),
+  legacy: createBrowserLegacyService(),
+  globals: createBrowserGlobalsService(),
+});
+
+export default createBrowserPlatformServices;

package/src/services/createBrowserRuntimeService.js

@@ -0,0 +1,26 @@
+/*
+Copyright 2026 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 { RuntimeService } from "@adobe/alloy-core/services" */
+
+/** @returns {RuntimeService} */
+const createBrowserRuntimeService = () => ({
+  setTimeout: window.setTimeout.bind(window),
+  clearTimeout: window.clearTimeout.bind(window),
+  atob: window.atob.bind(window),
+  btoa: window.btoa.bind(window),
+  TextEncoder: window.TextEncoder,
+  TextDecoder: window.TextDecoder,
+  now: () => Date.now(),
+});
+
+export default createBrowserRuntimeService;

package/src/services/createBrowserStorageService.js

@@ -0,0 +1,74 @@
+/*
+Copyright 2026 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 { NamespacedStorage, Storage, StorageService } from "@adobe/alloy-core/services" */
+
+import baseNamespace from "@adobe/alloy-core/constants/namespace.js";
+
+// On Safari with storage disabled, even referencing `window.localStorage`
+// throws — hence the try/catch around every access.
+/**
+ * @param {string} storageType - "localStorage" or "sessionStorage".
+ * @param {string} namespace
+ * @returns {Storage}
+ */
+const wrapStorageArea = (storageType, namespace) => ({
+  getItem(name) {
+    try {
+      return Promise.resolve(window[storageType].getItem(namespace + name));
+    } catch {
+      return Promise.resolve(null);
+    }
+  },
+  setItem(name, value) {
+    try {
+      window[storageType].setItem(namespace + name, value);
+      return Promise.resolve(true);
+    } catch {
+      return Promise.resolve(false);
+    }
+  },
+  removeItem(name) {
+    try {
+      window[storageType].removeItem(namespace + name);
+      return Promise.resolve(true);
+    } catch {
+      return Promise.resolve(false);
+    }
+  },
+  clear() {
+    try {
+      Object.keys(window[storageType]).forEach((key) => {
+        if (key.startsWith(namespace)) {
+          window[storageType].removeItem(key);
+        }
+      });
+      return Promise.resolve(true);
+    } catch {
+      return Promise.resolve(false);
+    }
+  },
+});
+
+/** @returns {StorageService} */
+const createBrowserStorageService = () => ({
+  createNamespacedStorage(additionalNamespace) {
+    const finalNamespace = baseNamespace + additionalNamespace;
+    /** @type {NamespacedStorage} */
+    return {
+      session: wrapStorageArea("sessionStorage", finalNamespace),
+      persistent: wrapStorageArea("localStorage", finalNamespace),
+    };
+  },
+});
+
+export default createBrowserStorageService;