@wix/astro 1.0.31 → 1.0.33

package/build-browser-runtime/setup.js

@@ -1,5 +1,747 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// ../../node_modules/@wix/monitoring/build/index.cjs
+var require_build = __commonJS({
+  "../../node_modules/@wix/monitoring/build/index.cjs"(exports, module) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var index_exports = {};
+    __export2(index_exports, {
+      createFallbackMonitoringClient: () => createFallbackMonitoringClient,
+      generateTagsAndContext: () => generateTagsAndContext
+    });
+    module.exports = __toCommonJS2(index_exports);
+    var validValue = (value) => value !== void 0 && value !== null && value !== "";
+    var pickByValidValues = (obj) => pickBy(obj, validValue);
+    function pickBy(object, predicate = (value) => !!value) {
+      if (!object) {
+        return {};
+      }
+      const result = {};
+      for (const key in object) {
+        if (predicate(object[key], key)) {
+          result[key] = object[key];
+        }
+      }
+      return result;
+    }
+    var generateTagsAndContext = (context) => {
+      const tags = pickByValidValues({
+        "app.id": context.appId,
+        "app.version": context.appVersion,
+        "app.instanceId": context.appInstanceId,
+        "extension.id": context.extensionId,
+        "extension.name": context.extensionName,
+        "extension.type": context.extensionType,
+        platform: context.platform
+      });
+      const contexts = pickBy(
+        {
+          "extension.data": pickByValidValues({
+            ...context.extensionData
+          }),
+          site: pickByValidValues({
+            url: context.siteUrl,
+            id: context.tenantType === "SITE" ? context.tenantId : void 0
+          }),
+          account: pickByValidValues({
+            id: context.tenantType === "ACCOUNT" ? context.tenantId : void 0
+          })
+        },
+        (value) => !!value && Object.keys(value).length > 0
+      );
+      return {
+        tags,
+        contexts
+      };
+    };
+    var FallbackMonitoringClient = class {
+      constructor(message) {
+        this.message = message;
+        this.captureException = () => {
+          console.error(this.message);
+        };
+        this.captureMessage = () => {
+          console.error(this.message);
+        };
+        this.startSpan = (spanOptions, callback) => {
+          console.error(this.message);
+          return callback(void 0);
+        };
+        this.startSpanManual = () => {
+          console.error(this.message);
+          return {
+            end: () => {
+            },
+            fail: () => {
+            }
+          };
+        };
+        this.endSpanManual = () => {
+          console.error(this.message);
+        };
+        this.addBreadcrumb = () => {
+          console.error(this.message);
+        };
+      }
+    };
+    var createFallbackMonitoringClient = (message) => {
+      return new FallbackMonitoringClient(message);
+    };
+  }
+});
+
+// ../../node_modules/@wix/monitoring-common/build/index.js
+var build_exports = {};
+__export(build_exports, {
+  getCallLocation: () => getCallLocation,
+  getCallStack: () => getCallStack
+});
+var getCallStack, getCallLocation;
+var init_build = __esm({
+  "../../node_modules/@wix/monitoring-common/build/index.js"() {
+    "use strict";
+    getCallStack = () => {
+      try {
+        throw new Error();
+      } catch (e) {
+        return e?.stack;
+      }
+    };
+    getCallLocation = (stack) => {
+      stack = stack ?? getCallStack();
+      const frames = stack?.trim().split("\n");
+      if (!frames) {
+        return null;
+      }
+      for (let i = frames.length - 1; i >= 0; i--) {
+        const match = frames[i].match(/https?:\/\/.+?(\/.+):(\d+):(\d+)/) ?? frames[i].match(/.*(\/[^/]+):(\d+):(\d+)/);
+        if (match) {
+          return {
+            file: match[1],
+            line: parseInt(match[2], 10) ?? 0,
+            column: parseInt(match[3], 10) ?? 0
+          };
+        }
+      }
+      return null;
+    };
+  }
+});
+
+// ../../node_modules/lodash/isObject.js
+var require_isObject = __commonJS({
+  "../../node_modules/lodash/isObject.js"(exports, module) {
+    "use strict";
+    function isObject(value) {
+      var type = typeof value;
+      return value != null && (type == "object" || type == "function");
+    }
+    module.exports = isObject;
+  }
+});
+
+// ../../node_modules/lodash/_freeGlobal.js
+var require_freeGlobal = __commonJS({
+  "../../node_modules/lodash/_freeGlobal.js"(exports, module) {
+    "use strict";
+    var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
+    module.exports = freeGlobal;
+  }
+});
+
+// ../../node_modules/lodash/_root.js
+var require_root = __commonJS({
+  "../../node_modules/lodash/_root.js"(exports, module) {
+    "use strict";
+    var freeGlobal = require_freeGlobal();
+    var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+    var root = freeGlobal || freeSelf || Function("return this")();
+    module.exports = root;
+  }
+});
+
+// ../../node_modules/lodash/now.js
+var require_now = __commonJS({
+  "../../node_modules/lodash/now.js"(exports, module) {
+    "use strict";
+    var root = require_root();
+    var now = function() {
+      return root.Date.now();
+    };
+    module.exports = now;
+  }
+});
+
+// ../../node_modules/lodash/_trimmedEndIndex.js
+var require_trimmedEndIndex = __commonJS({
+  "../../node_modules/lodash/_trimmedEndIndex.js"(exports, module) {
+    "use strict";
+    var reWhitespace = /\s/;
+    function trimmedEndIndex(string) {
+      var index = string.length;
+      while (index-- && reWhitespace.test(string.charAt(index))) {
+      }
+      return index;
+    }
+    module.exports = trimmedEndIndex;
+  }
+});
+
+// ../../node_modules/lodash/_baseTrim.js
+var require_baseTrim = __commonJS({
+  "../../node_modules/lodash/_baseTrim.js"(exports, module) {
+    "use strict";
+    var trimmedEndIndex = require_trimmedEndIndex();
+    var reTrimStart = /^\s+/;
+    function baseTrim(string) {
+      return string ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, "") : string;
+    }
+    module.exports = baseTrim;
+  }
+});
+
+// ../../node_modules/lodash/_Symbol.js
+var require_Symbol = __commonJS({
+  "../../node_modules/lodash/_Symbol.js"(exports, module) {
+    "use strict";
+    var root = require_root();
+    var Symbol2 = root.Symbol;
+    module.exports = Symbol2;
+  }
+});
+
+// ../../node_modules/lodash/_getRawTag.js
+var require_getRawTag = __commonJS({
+  "../../node_modules/lodash/_getRawTag.js"(exports, module) {
+    "use strict";
+    var Symbol2 = require_Symbol();
+    var objectProto = Object.prototype;
+    var hasOwnProperty = objectProto.hasOwnProperty;
+    var nativeObjectToString = objectProto.toString;
+    var symToStringTag = Symbol2 ? Symbol2.toStringTag : void 0;
+    function getRawTag(value) {
+      var isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];
+      try {
+        value[symToStringTag] = void 0;
+        var unmasked = true;
+      } catch (e) {
+      }
+      var result = nativeObjectToString.call(value);
+      if (unmasked) {
+        if (isOwn) {
+          value[symToStringTag] = tag;
+        } else {
+          delete value[symToStringTag];
+        }
+      }
+      return result;
+    }
+    module.exports = getRawTag;
+  }
+});
+
+// ../../node_modules/lodash/_objectToString.js
+var require_objectToString = __commonJS({
+  "../../node_modules/lodash/_objectToString.js"(exports, module) {
+    "use strict";
+    var objectProto = Object.prototype;
+    var nativeObjectToString = objectProto.toString;
+    function objectToString(value) {
+      return nativeObjectToString.call(value);
+    }
+    module.exports = objectToString;
+  }
+});
+
+// ../../node_modules/lodash/_baseGetTag.js
+var require_baseGetTag = __commonJS({
+  "../../node_modules/lodash/_baseGetTag.js"(exports, module) {
+    "use strict";
+    var Symbol2 = require_Symbol();
+    var getRawTag = require_getRawTag();
+    var objectToString = require_objectToString();
+    var nullTag = "[object Null]";
+    var undefinedTag = "[object Undefined]";
+    var symToStringTag = Symbol2 ? Symbol2.toStringTag : void 0;
+    function baseGetTag(value) {
+      if (value == null) {
+        return value === void 0 ? undefinedTag : nullTag;
+      }
+      return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
+    }
+    module.exports = baseGetTag;
+  }
+});
+
+// ../../node_modules/lodash/isObjectLike.js
+var require_isObjectLike = __commonJS({
+  "../../node_modules/lodash/isObjectLike.js"(exports, module) {
+    "use strict";
+    function isObjectLike(value) {
+      return value != null && typeof value == "object";
+    }
+    module.exports = isObjectLike;
+  }
+});
+
+// ../../node_modules/lodash/isSymbol.js
+var require_isSymbol = __commonJS({
+  "../../node_modules/lodash/isSymbol.js"(exports, module) {
+    "use strict";
+    var baseGetTag = require_baseGetTag();
+    var isObjectLike = require_isObjectLike();
+    var symbolTag = "[object Symbol]";
+    function isSymbol(value) {
+      return typeof value == "symbol" || isObjectLike(value) && baseGetTag(value) == symbolTag;
+    }
+    module.exports = isSymbol;
+  }
+});
+
+// ../../node_modules/lodash/toNumber.js
+var require_toNumber = __commonJS({
+  "../../node_modules/lodash/toNumber.js"(exports, module) {
+    "use strict";
+    var baseTrim = require_baseTrim();
+    var isObject = require_isObject();
+    var isSymbol = require_isSymbol();
+    var NAN = 0 / 0;
+    var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
+    var reIsBinary = /^0b[01]+$/i;
+    var reIsOctal = /^0o[0-7]+$/i;
+    var freeParseInt = parseInt;
+    function toNumber(value) {
+      if (typeof value == "number") {
+        return value;
+      }
+      if (isSymbol(value)) {
+        return NAN;
+      }
+      if (isObject(value)) {
+        var other = typeof value.valueOf == "function" ? value.valueOf() : value;
+        value = isObject(other) ? other + "" : other;
+      }
+      if (typeof value != "string") {
+        return value === 0 ? value : +value;
+      }
+      value = baseTrim(value);
+      var isBinary = reIsBinary.test(value);
+      return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value;
+    }
+    module.exports = toNumber;
+  }
+});
+
+// ../../node_modules/lodash/debounce.js
+var require_debounce = __commonJS({
+  "../../node_modules/lodash/debounce.js"(exports, module) {
+    "use strict";
+    var isObject = require_isObject();
+    var now = require_now();
+    var toNumber = require_toNumber();
+    var FUNC_ERROR_TEXT = "Expected a function";
+    var nativeMax = Math.max;
+    var nativeMin = Math.min;
+    function debounce(func, wait, options) {
+      var lastArgs, lastThis, maxWait, result, timerId, lastCallTime, lastInvokeTime = 0, leading = false, maxing = false, trailing = true;
+      if (typeof func != "function") {
+        throw new TypeError(FUNC_ERROR_TEXT);
+      }
+      wait = toNumber(wait) || 0;
+      if (isObject(options)) {
+        leading = !!options.leading;
+        maxing = "maxWait" in options;
+        maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;
+        trailing = "trailing" in options ? !!options.trailing : trailing;
+      }
+      function invokeFunc(time) {
+        var args = lastArgs, thisArg = lastThis;
+        lastArgs = lastThis = void 0;
+        lastInvokeTime = time;
+        result = func.apply(thisArg, args);
+        return result;
+      }
+      function leadingEdge(time) {
+        lastInvokeTime = time;
+        timerId = setTimeout(timerExpired, wait);
+        return leading ? invokeFunc(time) : result;
+      }
+      function remainingWait(time) {
+        var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime, timeWaiting = wait - timeSinceLastCall;
+        return maxing ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke) : timeWaiting;
+      }
+      function shouldInvoke(time) {
+        var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime;
+        return lastCallTime === void 0 || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= maxWait;
+      }
+      function timerExpired() {
+        var time = now();
+        if (shouldInvoke(time)) {
+          return trailingEdge(time);
+        }
+        timerId = setTimeout(timerExpired, remainingWait(time));
+      }
+      function trailingEdge(time) {
+        timerId = void 0;
+        if (trailing && lastArgs) {
+          return invokeFunc(time);
+        }
+        lastArgs = lastThis = void 0;
+        return result;
+      }
+      function cancel() {
+        if (timerId !== void 0) {
+          clearTimeout(timerId);
+        }
+        lastInvokeTime = 0;
+        lastArgs = lastCallTime = lastThis = timerId = void 0;
+      }
+      function flush() {
+        return timerId === void 0 ? result : trailingEdge(now());
+      }
+      function debounced() {
+        var time = now(), isInvoking = shouldInvoke(time);
+        lastArgs = arguments;
+        lastThis = this;
+        lastCallTime = time;
+        if (isInvoking) {
+          if (timerId === void 0) {
+            return leadingEdge(lastCallTime);
+          }
+          if (maxing) {
+            clearTimeout(timerId);
+            timerId = setTimeout(timerExpired, wait);
+            return invokeFunc(lastCallTime);
+          }
+        }
+        if (timerId === void 0) {
+          timerId = setTimeout(timerExpired, wait);
+        }
+        return result;
+      }
+      debounced.cancel = cancel;
+      debounced.flush = flush;
+      return debounced;
+    }
+    module.exports = debounce;
+  }
+});
+
+// ../../node_modules/lodash/throttle.js
+var require_throttle = __commonJS({
+  "../../node_modules/lodash/throttle.js"(exports, module) {
+    "use strict";
+    var debounce = require_debounce();
+    var isObject = require_isObject();
+    var FUNC_ERROR_TEXT = "Expected a function";
+    function throttle(func, wait, options) {
+      var leading = true, trailing = true;
+      if (typeof func != "function") {
+        throw new TypeError(FUNC_ERROR_TEXT);
+      }
+      if (isObject(options)) {
+        leading = "leading" in options ? !!options.leading : leading;
+        trailing = "trailing" in options ? !!options.trailing : trailing;
+      }
+      return debounce(func, wait, {
+        "leading": leading,
+        "maxWait": wait,
+        "trailing": trailing
+      });
+    }
+    module.exports = throttle;
+  }
+});
+
+// ../../node_modules/@wix/monitoring-velo/build/index.cjs
+var require_build2 = __commonJS({
+  "../../node_modules/@wix/monitoring-velo/build/index.cjs"(exports, module) {
+    "use strict";
+    var __create2 = Object.create;
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __getProtoOf2 = Object.getPrototypeOf;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(
+      // If the importer is in node compatibility mode or this is not an ESM
+      // file that has been converted to a CommonJS file using a Babel-
+      // compatible transform (i.e. "__esModule" has not been set), then set
+      // "default" to the CommonJS "module.exports" for node compatibility.
+      isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", { value: mod, enumerable: true }) : target,
+      mod
+    ));
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var index_exports = {};
+    __export2(index_exports, {
+      createVeloMonitoringClient: () => createVeloMonitoringClient2
+    });
+    module.exports = __toCommonJS2(index_exports);
+    var import_monitoring = require_build();
+    var import_monitoring_common = (init_build(), __toCommonJS(build_exports));
+    var generateId = () => {
+      return typeof crypto !== "undefined" && typeof crypto.randomUUID === "function" ? crypto.randomUUID() : "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(e) {
+        const i = 16 * Math.random() | 0;
+        return ("x" === e ? i : 3 & i | 8).toString(16);
+      });
+    };
+    var stringifySafe = (value) => {
+      try {
+        return JSON.stringify(value);
+      } catch (error) {
+        return `Failed to stringify log value: ${error?.toString()}`;
+      }
+    };
+    var buildTelemetryPayload = (options, params) => {
+      const { namespace, producer, req, requestId } = options;
+      const {
+        message,
+        level = "INFO",
+        timestamp = Date.now(),
+        tags,
+        contexts
+      } = params;
+      const { __sourceLocation, ...restOfContext } = contexts ?? {};
+      let siteUrl = "";
+      if (req) {
+        try {
+          if (req.headers.get("referer")) {
+            siteUrl = new URL(req.headers.get("referer") ?? "").origin;
+          } else {
+            siteUrl = new URL(req.url).origin;
+          }
+        } catch (e) {
+        }
+      }
+      const messageParts = [message];
+      if (tags) {
+        messageParts.push(stringifySafe(tags));
+      }
+      if (Object.keys(restOfContext).length > 0) {
+        messageParts.push(stringifySafe(restOfContext));
+      }
+      const sourceLocation = __sourceLocation ?? (0, import_monitoring_common.getCallLocation)();
+      return {
+        insertId: generateId(),
+        timestamp: new Date(timestamp).toISOString(),
+        severity: level.toUpperCase(),
+        labels: {
+          tenantId: "",
+          namespace,
+          ...siteUrl ? { siteUrl } : {}
+        },
+        operation: {
+          id: requestId ?? generateId(),
+          producer
+        },
+        ...sourceLocation ? { sourceLocation } : {},
+        jsonPayload: {
+          message: messageParts.join(" ")
+        }
+      };
+    };
+    var TELEMETRY_URL = "https://www.wixapis.com/wixcode/v1/telemetry/telemetry-messages";
+    var MAX_BATCH_SIZE = 100;
+    var THROTTLE_DURATION = 300;
+    var report = async (messages, authToken = "", fetch = globalThis.fetch) => {
+      try {
+        await fetch(TELEMETRY_URL, {
+          method: "POST",
+          body: JSON.stringify({ messages }),
+          headers: {
+            Authorization: authToken
+          }
+        });
+      } catch (_e) {
+      }
+    };
+    var import_throttle = __toESM2(require_throttle(), 1);
+    var BatchQueue = class {
+      constructor(options) {
+        this.options = options;
+        this.queue = [];
+        this.batchQueuePromise = null;
+        this.resolveBatchQueuePromise = null;
+        this.flushThrottled = (0, import_throttle.default)(
+          () => this.flush(),
+          options.throttleDuration,
+          {
+            leading: false
+          }
+        );
+      }
+      flush() {
+        const events = this.queue.splice(0);
+        this.options.flushHandler(events).then(() => {
+          this.resolveBatchQueuePromise?.();
+          this.resolveBatchQueuePromise = null;
+        });
+        this.batchQueuePromise = null;
+      }
+      enqueue(payload) {
+        this.queue.push(payload);
+        if (!this.batchQueuePromise) {
+          this.batchQueuePromise = new Promise((resolve) => {
+            this.resolveBatchQueuePromise = resolve;
+          });
+          this.options.onBatchQueueCreated?.(this.batchQueuePromise);
+        }
+        if (this.queue.length === this.options.maxBatchSize) {
+          this.flushThrottled.cancel();
+          this.flush();
+        } else {
+          this.flushThrottled();
+        }
+      }
+    };
+    var isPromise = (value) => typeof value?.then === "function";
+    var import_monitoring_common2 = (init_build(), __toCommonJS(build_exports));
+    var VeloClient = class {
+      constructor(options) {
+        this.options = options;
+        this.reportError = (captureContext = {}, e) => {
+          const { tags, contexts } = captureContext;
+          const messagePayload = buildTelemetryPayload(this.options, {
+            message: e?.toString() ?? "Unknown error",
+            level: "error",
+            tags,
+            contexts: {
+              __sourceLocation: (0, import_monitoring_common2.getCallLocation)(e?.stack),
+              ...contexts
+            }
+          });
+          this.batchQueue.enqueue(messagePayload);
+        };
+        this.captureException = (error, captureContext) => {
+          this.reportError(captureContext, error);
+        };
+        this.captureMessage = (message, captureContext = {}) => {
+          const { level = "info", tags, contexts } = captureContext;
+          const messagePayload = buildTelemetryPayload(this.options, {
+            message,
+            level,
+            tags,
+            contexts
+          });
+          this.batchQueue.enqueue(messagePayload);
+        };
+        this.startSpan = (spanOptions, callback) => {
+          let res;
+          try {
+            res = callback();
+            if (isPromise(res)) {
+              res = res.then((_res) => {
+                return _res;
+              }).catch((e) => {
+                this.reportError(spanOptions, e);
+                throw e;
+              });
+            } else {
+            }
+          } catch (e) {
+            this.reportError(spanOptions, e);
+            throw e;
+          }
+          return res;
+        };
+        this.addBreadcrumb = (breadcrumb) => {
+        };
+        const { getAuthToken, fetch } = options;
+        this.batchQueue = new BatchQueue({
+          maxBatchSize: MAX_BATCH_SIZE,
+          throttleDuration: THROTTLE_DURATION,
+          flushHandler: (messages) => getAuthToken().then((token) => report(messages, token, fetch)),
+          onBatchQueueCreated: options.onBatchQueueCreated
+        });
+      }
+      startSpanManual(spanOptions) {
+        return {
+          end: () => {
+          },
+          fail: (error) => {
+            this.reportError(spanOptions, error);
+          }
+        };
+      }
+      endSpanManual(spanOptions) {
+      }
+    };
+    var createVeloMonitoringClient2 = (options) => {
+      const { getAuthToken } = options;
+      if (!getAuthToken) {
+        return (0, import_monitoring.createFallbackMonitoringClient)("Missing getAuthToken");
+      }
+      return new VeloClient(options);
+    };
+  }
+});
+
 // src/client-context/setup.ts
-import { wixContext } from "@wix/sdk-context";
+import { wixContext as wixContext2 } from "@wix/sdk-context";
+
+// ../../node_modules/@wix/headless-site/dist/esm/host-module.js
+var import_monitoring_velo = __toESM(require_build2());
 
 // ../../node_modules/@wix/headless-site/dist/esm/headers/common-config-header.js
 var COMMON_CONFIG_HEADER_NAME = "commonConfig";
@@ -46,6 +788,99 @@ var getPassThroughHeaders = () => {
   }, {});
 };
 
+// ../../node_modules/@wix/sdk-runtime/build/context.js
+import { wixContext } from "@wix/sdk-context";
+function resolveContext() {
+  const oldContext = typeof $wixContext !== "undefined" && $wixContext.initWixModules ? $wixContext.initWixModules : typeof globalThis.__wix_context__ !== "undefined" && globalThis.__wix_context__.initWixModules ? globalThis.__wix_context__.initWixModules : void 0;
+  if (oldContext) {
+    return {
+      // @ts-expect-error
+      initWixModules(modules, elevated) {
+        return runWithoutContext(() => oldContext(modules, elevated));
+      },
+      fetchWithAuth() {
+        throw new Error("fetchWithAuth is not available in this context");
+      },
+      graphql() {
+        throw new Error("graphql is not available in this context");
+      }
+    };
+  }
+  const contextualClient = typeof $wixContext !== "undefined" ? $wixContext.client : typeof wixContext.client !== "undefined" ? wixContext.client : typeof globalThis.__wix_context__ !== "undefined" ? globalThis.__wix_context__.client : void 0;
+  const elevatedClient = typeof $wixContext !== "undefined" ? $wixContext.elevatedClient : typeof wixContext.elevatedClient !== "undefined" ? wixContext.elevatedClient : typeof globalThis.__wix_context__ !== "undefined" ? globalThis.__wix_context__.elevatedClient : void 0;
+  if (!contextualClient && !elevatedClient) {
+    return;
+  }
+  return {
+    initWixModules(wixModules, elevated) {
+      if (elevated) {
+        if (!elevatedClient) {
+          throw new Error("An elevated client is required to use elevated modules. Make sure to initialize the Wix context with an elevated client before using elevated SDK modules");
+        }
+        return runWithoutContext(() => elevatedClient.use(wixModules));
+      }
+      if (!contextualClient) {
+        throw new Error("Wix context is not available. Make sure to initialize the Wix context before using SDK modules");
+      }
+      return runWithoutContext(() => contextualClient.use(wixModules));
+    },
+    fetchWithAuth: (urlOrRequest, requestInit) => {
+      if (!contextualClient) {
+        throw new Error("Wix context is not available. Make sure to initialize the Wix context before using SDK modules");
+      }
+      return contextualClient.fetchWithAuth(urlOrRequest, requestInit);
+    },
+    getAuth() {
+      if (!contextualClient) {
+        throw new Error("Wix context is not available. Make sure to initialize the Wix context before using SDK modules");
+      }
+      return contextualClient.auth;
+    },
+    async graphql(query, variables, opts) {
+      if (!contextualClient) {
+        throw new Error("Wix context is not available. Make sure to initialize the Wix context before using SDK modules");
+      }
+      return contextualClient.graphql(query, variables, opts);
+    }
+  };
+}
+function runWithoutContext(fn) {
+  const globalContext = globalThis.__wix_context__;
+  const moduleContext = {
+    client: wixContext.client,
+    elevatedClient: wixContext.elevatedClient
+  };
+  let closureContext;
+  globalThis.__wix_context__ = void 0;
+  wixContext.client = void 0;
+  wixContext.elevatedClient = void 0;
+  if (typeof $wixContext !== "undefined") {
+    closureContext = {
+      client: $wixContext?.client,
+      elevatedClient: $wixContext?.elevatedClient
+    };
+    delete $wixContext.client;
+    delete $wixContext.elevatedClient;
+  }
+  try {
+    return fn();
+  } finally {
+    globalThis.__wix_context__ = globalContext;
+    wixContext.client = moduleContext.client;
+    wixContext.elevatedClient = moduleContext.elevatedClient;
+    if (typeof $wixContext !== "undefined") {
+      $wixContext.client = closureContext.client;
+      $wixContext.elevatedClient = closureContext.elevatedClient;
+    }
+  }
+}
+
+// ../../node_modules/@wix/headless-site/dist/esm/utils/auth-utils.js
+var resolveAuthToken = () => {
+  var _resolveContext;
+  return (_resolveContext = resolveContext()) == null ? void 0 : _resolveContext.getAuth().getTokens().accessToken.value;
+};
+
 // ../../node_modules/@wix/headless-site/dist/esm/host-module.js
 var createHostModule = () => {
   return {
@@ -58,7 +893,24 @@ var createHostModule = () => {
         essentials: {
           get passThroughHeaders() {
             return getPassThroughHeaders();
+          },
+          language: "en",
+          locale: "en-US",
+          timezone: "UTC"
+        },
+        getMonitoringClient: () => {
+          let producer = "unknown";
+          let req;
+          if (typeof document !== "undefined") {
+            producer = document.location.href;
+            req = new Request(document.location.href);
           }
+          return (0, import_monitoring_velo.createVeloMonitoringClient)({
+            namespace: "Headless",
+            producer,
+            getAuthToken: async () => resolveAuthToken(),
+            req
+          });
         }
       };
     }
@@ -117,7 +969,7 @@ function isCookieValue(value) {
 
 // src/client-context/setup.ts
 function setup(options) {
-  if (wixContext.client != null) {
+  if (wixContext2.client != null) {
     return;
   }
   if (!location.pathname.startsWith("/_wix/extensions/backoffice")) {