@cloudcare/cocos-sdk 0.1.1-alpha.1 → 0.1.1-alpha.2

package/web/bootstrap.js

@@ -0,0 +1,1042 @@
+"use strict";
+var CocosWebSDK = (function() {
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __commonJS = function(cb, mod) {
+    return function __require() {
+      try {
+        return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+      } catch (e) {
+        throw mod = 0, e;
+      }
+    };
+  };
+
+  // packages/cocos/dist/creator2/core/validation.js
+  var require_validation = __commonJS({
+    "packages/cocos/dist/creator2/core/validation.js": function(exports) {
+      "use strict";
+      var __assign = exports && exports.__assign || function() {
+        __assign = Object.assign || function(t) {
+          for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+              t[p] = s[p];
+          }
+          return t;
+        };
+        return __assign.apply(this, arguments);
+      };
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.samplingRate = samplingRate;
+      exports.samplingPercentage = samplingPercentage;
+      exports.validatedSamplingConfig = validatedSamplingConfig;
+      exports.requireText = requireText;
+      function samplingRate(value, name) {
+        if (value === void 0)
+          return void 0;
+        if (!Number.isFinite(value) || value < 0 || value > 1) {
+          throw new RangeError("".concat(name, " must be between 0 and 1"));
+        }
+        return value;
+      }
+      function samplingPercentage(value, name) {
+        if (value === void 0)
+          return void 0;
+        if (!Number.isFinite(value) || value < 0 || value > 100) {
+          throw new RangeError("".concat(name, " must be between 0 and 100"));
+        }
+        return value;
+      }
+      function validatedSamplingConfig(config, scope, fields) {
+        var result = __assign({}, config);
+        fields.forEach(function(_a) {
+          var percentageField = _a[0], legacyField = _a[1];
+          var percentage = result[percentageField];
+          if (percentage !== void 0) {
+            samplingPercentage(percentage, "".concat(scope, ".").concat(percentageField));
+            delete result[legacyField];
+            return;
+          }
+          samplingRate(result[legacyField], "".concat(scope, ".").concat(legacyField));
+        });
+        return result;
+      }
+      function requireText(value, name) {
+        if (!value.trim())
+          throw new TypeError("".concat(name, " must not be empty"));
+        return value;
+      }
+    }
+  });
+
+  // packages/cocos/dist/creator2/core/version.js
+  var require_version = __commonJS({
+    "packages/cocos/dist/creator2/core/version.js": function(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.FT_COCOS_SDK_BRIDGE_INFO = exports.FT_COCOS_SDK_BRIDGE_INFO_KEY = exports.FT_COCOS_SDK_VERSION_KEY = exports.FT_COCOS_SDK_VERSION = void 0;
+      exports.FT_COCOS_SDK_VERSION = "0.1.1-alpha.2";
+      exports.FT_COCOS_SDK_VERSION_KEY = "sdk_package_cocos";
+      exports.FT_COCOS_SDK_BRIDGE_INFO_KEY = "sdk_bridge_info";
+      exports.FT_COCOS_SDK_BRIDGE_INFO = JSON.stringify({
+        cocos: exports.FT_COCOS_SDK_VERSION
+      });
+    }
+  });
+
+  // packages/cocos/dist/creator2/core/modules.js
+  var require_modules = __commonJS({
+    "packages/cocos/dist/creator2/core/modules.js": function(exports) {
+      "use strict";
+      var __assign = exports && exports.__assign || function() {
+        __assign = Object.assign || function(t) {
+          for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+              t[p] = s[p];
+          }
+          return t;
+        };
+        return __assign.apply(this, arguments);
+      };
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.FTTrace = exports.FTLogger = exports.FTRUM = exports.FTMobileAgent = exports.FTSDKOwnership = void 0;
+      var validation_js_1 = require_validation();
+      var version_js_1 = require_version();
+      var FTSDKOwnership = (
+        /** @class */
+        (function() {
+          function FTSDKOwnership2() {
+            this.mode = "unclaimed";
+          }
+          FTSDKOwnership2.prototype.claimStandalone = function() {
+            if (this.mode === "native-host") {
+              throw new Error("The native host owns SDK initialization in Hybrid mode");
+            }
+            this.mode = "standalone";
+          };
+          FTSDKOwnership2.prototype.claimNativeHost = function() {
+            if (this.mode === "standalone") {
+              throw new Error("Standalone initialization and native-host attachment are mutually exclusive");
+            }
+            this.mode = "native-host";
+          };
+          FTSDKOwnership2.prototype.releaseNativeHost = function() {
+            if (this.mode === "native-host")
+              this.mode = "unclaimed";
+          };
+          FTSDKOwnership2.prototype.releaseStandalone = function() {
+            if (this.mode === "standalone")
+              this.mode = "unclaimed";
+          };
+          FTSDKOwnership2.prototype.assertNativeHostDoesNotOwnSDK = function() {
+            if (this.mode === "native-host") {
+              throw new Error("The native host owns the native SDK in Hybrid mode");
+            }
+          };
+          return FTSDKOwnership2;
+        })()
+      );
+      exports.FTSDKOwnership = FTSDKOwnership;
+      function compact(value) {
+        var source = value;
+        var result = {};
+        Object.keys(value).forEach(function(key) {
+          if (source[key] !== void 0)
+            result[key] = source[key];
+        });
+        return result;
+      }
+      function withBridgeInfo(attributes) {
+        var _a;
+        return __assign((_a = {}, _a[version_js_1.FT_COCOS_SDK_BRIDGE_INFO_KEY] = version_js_1.FT_COCOS_SDK_BRIDGE_INFO, _a), attributes || {});
+      }
+      var FTMobileAgent = (
+        /** @class */
+        (function() {
+          function FTMobileAgent2(transport, ownership) {
+            if (ownership === void 0) {
+              ownership = new FTSDKOwnership();
+            }
+            this.transport = transport;
+            this.ownership = ownership;
+          }
+          FTMobileAgent2.prototype.start = function(config) {
+            var _a;
+            if (!config.datakitUrl && !(config.datawayUrl && config.clientToken)) {
+              throw new TypeError("Configure datakitUrl or datawayUrl with clientToken");
+            }
+            this.ownership.claimStandalone();
+            this.transport.invoke("sdk.configure", compact(__assign(__assign({}, config), { globalContext: __assign(__assign({}, config.globalContext || {}), (_a = {}, _a[version_js_1.FT_COCOS_SDK_VERSION_KEY] = version_js_1.FT_COCOS_SDK_VERSION, _a)) })));
+          };
+          FTMobileAgent2.prototype.bindUser = function(user) {
+            this.transport.invoke("sdk.bindUser", typeof user === "string" ? { userId: (0, validation_js_1.requireText)(user, "userId") } : user);
+          };
+          FTMobileAgent2.prototype.unbindUser = function() {
+            this.transport.invoke("sdk.unbindUser");
+          };
+          FTMobileAgent2.prototype.shutdown = function() {
+            this.ownership.assertNativeHostDoesNotOwnSDK();
+            this.transport.invoke("sdk.shutdown");
+            this.ownership.releaseStandalone();
+          };
+          return FTMobileAgent2;
+        })()
+      );
+      exports.FTMobileAgent = FTMobileAgent;
+      var FTRUM = (
+        /** @class */
+        (function() {
+          function FTRUM2(transport, ownership) {
+            if (ownership === void 0) {
+              ownership = new FTSDKOwnership();
+            }
+            this.transport = transport;
+            this.ownership = ownership;
+          }
+          FTRUM2.prototype.start = function(config) {
+            var payload = (0, validation_js_1.validatedSamplingConfig)(config, "rum", [
+              ["sessionSamplingRate", "sampleRate"],
+              ["sessionOnErrorSamplingRate", "sessionOnErrorSampleRate"]
+            ]);
+            this.ownership.claimStandalone();
+            this.transport.invoke("rum.configure", compact(payload));
+          };
+          FTRUM2.prototype.startView = function(name, attributes) {
+            this.transport.invoke("rum.startView", {
+              name: (0, validation_js_1.requireText)(name, "view name"),
+              attributes: withBridgeInfo(attributes)
+            });
+          };
+          FTRUM2.prototype.stopView = function(attributes) {
+            this.transport.invoke("rum.stopView", { attributes: withBridgeInfo(attributes) });
+          };
+          FTRUM2.prototype.addAction = function(name, type, attributes) {
+            if (type === void 0) {
+              type = "click";
+            }
+            this.transport.invoke("rum.addAction", {
+              name: (0, validation_js_1.requireText)(name, "action name"),
+              type: (0, validation_js_1.requireText)(type, "action type"),
+              attributes: withBridgeInfo(attributes)
+            });
+          };
+          FTRUM2.prototype.startAction = function(name, type, attributes) {
+            if (type === void 0) {
+              type = "click";
+            }
+            this.transport.invoke("rum.startAction", {
+              name: (0, validation_js_1.requireText)(name, "action name"),
+              type: (0, validation_js_1.requireText)(type, "action type"),
+              attributes: withBridgeInfo(attributes)
+            });
+          };
+          FTRUM2.prototype.addError = function(message, stack, type, state, attributes) {
+            if (type === void 0) {
+              type = "cocos_error";
+            }
+            if (state === void 0) {
+              state = "run";
+            }
+            this.transport.invoke("rum.addError", {
+              message: message,
+              stack: stack,
+              type: type,
+              state: state,
+              attributes: withBridgeInfo(attributes)
+            });
+          };
+          FTRUM2.prototype.addLongTask = function(stack, durationNs, attributes) {
+            this.transport.invoke("rum.addLongTask", {
+              stack: stack,
+              durationNs: durationNs,
+              attributes: withBridgeInfo(attributes)
+            });
+          };
+          FTRUM2.prototype.startResource = function(key, attributes) {
+            this.transport.invoke("rum.startResource", {
+              key: (0, validation_js_1.requireText)(key, "resource key"),
+              attributes: withBridgeInfo(attributes)
+            });
+          };
+          FTRUM2.prototype.stopResource = function(key, attributes) {
+            this.transport.invoke("rum.stopResource", {
+              key: (0, validation_js_1.requireText)(key, "resource key"),
+              attributes: withBridgeInfo(attributes)
+            });
+          };
+          FTRUM2.prototype.addResource = function(key, content, metrics) {
+            this.transport.invoke("rum.addResource", {
+              key: (0, validation_js_1.requireText)(key, "resource key"),
+              content: content,
+              metrics: metrics
+            });
+          };
+          return FTRUM2;
+        })()
+      );
+      exports.FTRUM = FTRUM;
+      var FTLogger = (
+        /** @class */
+        (function() {
+          function FTLogger2(transport, ownership) {
+            if (ownership === void 0) {
+              ownership = new FTSDKOwnership();
+            }
+            this.transport = transport;
+            this.ownership = ownership;
+          }
+          FTLogger2.prototype.start = function(config) {
+            var payload = (0, validation_js_1.validatedSamplingConfig)(config, "logger", [
+              ["logSamplingRate", "sampleRate"]
+            ]);
+            this.ownership.claimStandalone();
+            this.transport.invoke("logger.configure", compact(payload));
+          };
+          FTLogger2.prototype.log = function(content, level, attributes) {
+            if (level === void 0) {
+              level = "info";
+            }
+            this.transport.invoke("logger.log", {
+              content: content,
+              level: level,
+              attributes: withBridgeInfo(attributes)
+            });
+          };
+          return FTLogger2;
+        })()
+      );
+      exports.FTLogger = FTLogger;
+      var FTTrace = (
+        /** @class */
+        (function() {
+          function FTTrace2(transport, ownership) {
+            if (ownership === void 0) {
+              ownership = new FTSDKOwnership();
+            }
+            this.transport = transport;
+            this.ownership = ownership;
+          }
+          FTTrace2.prototype.start = function(config) {
+            var payload = (0, validation_js_1.validatedSamplingConfig)(config, "trace", [
+              ["traceSamplingRate", "sampleRate"]
+            ]);
+            this.ownership.claimStandalone();
+            this.transport.invoke("trace.configure", compact(payload));
+          };
+          FTTrace2.prototype.getHeaders = function(url, resourceKey) {
+            return this.transport.invoke("trace.getHeaders", {
+              url: (0, validation_js_1.requireText)(url, "url"),
+              resourceKey: resourceKey
+            }) || {};
+          };
+          return FTTrace2;
+        })()
+      );
+      exports.FTTrace = FTTrace;
+    }
+  });
+
+  // packages/cocos/dist/creator2/web/runtime.js
+  var require_runtime = __commonJS({
+    "packages/cocos/dist/creator2/web/runtime.js": function(exports) {
+      "use strict";
+      var __assign = exports && exports.__assign || function() {
+        __assign = Object.assign || function(t) {
+          for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+              t[p] = s[p];
+          }
+          return t;
+        };
+        return __assign.apply(this, arguments);
+      };
+      var __spreadArray = exports && exports.__spreadArray || function(to, from, pack) {
+        if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+          if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+          }
+        }
+        return to.concat(ar || Array.prototype.slice.call(from));
+      };
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.FTWebRuntime = void 0;
+      exports.bootstrapWeb = bootstrapWeb;
+      var validation_js_1 = require_validation();
+      var version_js_1 = require_version();
+      var TRACE_TYPES = {
+        ddTrace: "ddtrace",
+        zipkinMultiHeader: "zipkin",
+        zipkinSingleHeader: "zipkin_single_header",
+        traceparent: "w3c_traceparent",
+        skywalking: "skywalking_v3",
+        jaeger: "jaeger"
+      };
+      var FTWebRuntime = (
+        /** @class */
+        (function() {
+          function FTWebRuntime2(config, target, beforeEngine) {
+            if (beforeEngine === void 0) {
+              beforeEngine = false;
+            }
+            var _this = this;
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u;
+            this.config = config;
+            this.protocol = 1;
+            this.replayStarted = false;
+            config = JSON.parse(JSON.stringify(config));
+            this.config = config;
+            var web = config.web;
+            if (!web)
+              throw new Error("Configure web explicitly before starting the Web SDK");
+            var connection = reportingConnection(web);
+            var replay = web.replay;
+            if (replay) {
+              var keys = ["enabled", "sessionReplaySamplingRate", "sessionReplayOnErrorSamplingRate", "canvasPrivacy", "canvasId", "captureFps", "maxImageDimension", "quality", "maxFrameBytes"];
+              for (var _i = 0, _v = Object.keys(replay); _i < _v.length; _i++) {
+                var key = _v[_i];
+                if (!keys.includes(key))
+                  throw new Error("Unsupported web.replay.".concat(key));
+              }
+            }
+            if (!config.rum && !config.logger)
+              throw new Error("Enable rum or logger for Web collection");
+            if (!config.rum && (((_a = config.autoTrack) === null || _a === void 0 ? void 0 : _a.scenes) || ((_b = config.autoTrack) === null || _b === void 0 ? void 0 : _b.actions) || ((_c = config.autoTrack) === null || _c === void 0 ? void 0 : _c.errors) || ((_d = config.autoTrack) === null || _d === void 0 ? void 0 : _d.network)))
+              throw new Error("Cocos RUM tracking requires rum configuration");
+            if (config.trace && !config.rum)
+              throw new Error("Web tracing requires RUM");
+            if (((_e = config.autoTrack) === null || _e === void 0 ? void 0 : _e.console) && !config.logger)
+              throw new Error("Console tracking requires logger");
+            if (replay && (!beforeEngine || !config.rum))
+              throw new Error("Web Replay must be configured before engine boot with RUM enabled");
+            if (replay && replay.enabled !== true)
+              throw new Error("Web Replay requires enabled: true");
+            if ((replay === null || replay === void 0 ? void 0 : replay.canvasPrivacy) !== void 0 && !["block", "allow"].includes(replay.canvasPrivacy)) {
+              throw new Error("web.replay.canvasPrivacy must be block or allow");
+            }
+            var fps = integer(replay === null || replay === void 0 ? void 0 : replay.captureFps, 1, 5, 1, "captureFps");
+            var dimension = integer(replay === null || replay === void 0 ? void 0 : replay.maxImageDimension, 1, 2048, 720, "maxImageDimension");
+            if (web.outsideViewName !== void 0 && !web.outsideViewName.trim())
+              throw new Error("outsideViewName must not be empty");
+            if ((_f = web.allowedTracingUrls) === null || _f === void 0 ? void 0 : _f.some(function(url) {
+              return typeof url !== "string" || !/^https?:\/\//.test(url);
+            })) {
+              throw new Error("allowedTracingUrls must contain absolute HTTP(S) URL prefixes");
+            }
+            if ((replay === null || replay === void 0 ? void 0 : replay.quality) !== void 0 && !(typeof replay.quality === "number" ? Number.isFinite(replay.quality) && replay.quality >= 0 && replay.quality <= 1 : ["low", "medium", "high"].includes(replay.quality)))
+              throw new Error("web.replay.quality must be low, medium, high, or a number between 0 and 1");
+            var quality = (replay === null || replay === void 0 ? void 0 : replay.quality) === "low" ? 0.25 : (replay === null || replay === void 0 ? void 0 : replay.quality) === "medium" ? 0.4 : (replay === null || replay === void 0 ? void 0 : replay.quality) === "high" ? 0.5 : (_g = replay === null || replay === void 0 ? void 0 : replay.quality) !== null && _g !== void 0 ? _g : 0.4;
+            var maxBytes = integer(replay === null || replay === void 0 ? void 0 : replay.maxFrameBytes, 1024, 1048576, 4e4, "web.replay.maxFrameBytes");
+            var common = __assign(__assign({}, connection), { service: (_h = config.sdk) === null || _h === void 0 ? void 0 : _h.serviceName, env: (_j = config.sdk) === null || _j === void 0 ? void 0 : _j.env, telemetrySampleRate: 0 });
+            var rumConfig = config.rum ? __assign(__assign({}, common), {
+              applicationId: required(web.applicationId, "web.applicationId"),
+              sessionSampleRate: percentage(config.rum.sessionSamplingRate, config.rum.sampleRate, 100, "sessionSamplingRate"),
+              sessionOnErrorSampleRate: percentage(config.rum.sessionOnErrorSamplingRate, config.rum.sessionOnErrorSampleRate, 0, "sessionOnErrorSamplingRate"),
+              trackViewsManually: true,
+              trackUserInteractions: false,
+              sessionReplaySampleRate: percentage(replay === null || replay === void 0 ? void 0 : replay.sessionReplaySamplingRate, void 0, replay ? 100 : 0, "sessionReplaySamplingRate"),
+              sessionReplayOnErrorSampleRate: percentage(replay === null || replay === void 0 ? void 0 : replay.sessionReplayOnErrorSamplingRate, void 0, 0, "sessionReplayOnErrorSamplingRate"),
+              allowedTracingUrls: config.trace ? web.allowedTracingUrls || [] : [],
+              tracingSampleRate: percentage((_k = config.trace) === null || _k === void 0 ? void 0 : _k.traceSamplingRate, (_l = config.trace) === null || _l === void 0 ? void 0 : _l.sampleRate, 100, "traceSamplingRate"),
+              traceType: TRACE_TYPES[((_m = config.trace) === null || _m === void 0 ? void 0 : _m.traceType) || "ddTrace"],
+              replayCanvasEnabled: !!replay,
+              replayCanvasMode: "auto",
+              replayCanvasSampling: fps,
+              replayCanvasAutoInterval: 1e3 / fps,
+              // The WebGL plugin otherwise retains a 1000ms cooldown, overriding higher target FPS.
+              // One in-flight encode and the capture interval bound load; 1ms is the minimum accepted cooldown.
+              replayCanvasAutoCooldown: 1,
+              replayCanvasQuality: quality,
+              replayCanvasMaxEncodedBytes: maxBytes,
+              replayCanvasMaxCanvasSize: dimension,
+              replayCanvasMaxConcurrentEncodes: 1,
+              replayCanvasAutoMaxPerRun: 1,
+              defaultPrivacyLevel: "mask",
+              shouldRecordCanvas: function(canvas) {
+                var _a2;
+                if (!_this.replayStarted || (replay === null || replay === void 0 ? void 0 : replay.canvasPrivacy) !== "allow" || canvas.id !== (replay.canvasId || "GameCanvas"))
+                  return false;
+                try {
+                  return ((_a2 = _this.privacyCheck) === null || _a2 === void 0 ? void 0 : _a2.call(_this)) === true;
+                } catch (_b2) {
+                  return false;
+                }
+              },
+              beforeSend: function(event) {
+                var _a2, _b2, _c2;
+                var manual = !!((_a2 = event.context) === null || _a2 === void 0 ? void 0 : _a2[version_js_1.FT_COCOS_SDK_BRIDGE_INFO_KEY]);
+                if (event.type === "resource")
+                  return ((_b2 = config.autoTrack) === null || _b2 === void 0 ? void 0 : _b2.network) === true;
+                if (event.type === "error")
+                  return manual || ((_c2 = config.autoTrack) === null || _c2 === void 0 ? void 0 : _c2.errors) === true;
+                if (event.type === "long_task")
+                  return web.trackLongTasks === true;
+                return true;
+              }
+            }) : void 0;
+            var logsConfig = config.logger ? __assign(__assign({}, common), { sessionSampleRate: percentage(config.logger.logSamplingRate, config.logger.sampleRate, 100, "logSamplingRate"), forwardErrorsToLogs: false, forwardConsoleLogs: [], forwardReports: [] }) : void 0;
+            this.rum = rumConfig ? target.DATAFLUX_RUM : void 0;
+            this.logs = logsConfig ? target.DATAFLUX_LOGS : void 0;
+            if (rumConfig && (!this.rum || typeof this.rum.getInitConfiguration !== "function"))
+              throw new Error("Load the Browser RUM bundle before Cocos");
+            if (logsConfig && (!this.logs || typeof this.logs.getInitConfiguration !== "function"))
+              throw new Error("Load the Browser Logs bundle before Cocos");
+            if (((_o = this.rum) === null || _o === void 0 ? void 0 : _o.getInitConfiguration()) || ((_p = this.logs) === null || _p === void 0 ? void 0 : _p.getInitConfiguration()))
+              throw new Error("Browser SDK already initialized; use the page bootstrap and attach()");
+            if (replay && !((_q = target.DATAFLUX_RUM_WEBGL) === null || _q === void 0 ? void 0 : _q.webglReplayPlugin))
+              throw new Error("Load the Browser WebGL bundle before Cocos");
+            if (rumConfig && this.rum) {
+              var accepted_1 = false;
+              var ownershipPlugin = { name: "cocos-adapter", onInit: function() {
+                accepted_1 = true;
+              } };
+              this.rum.init(__assign(__assign({}, rumConfig), { plugins: __spreadArray([ownershipPlugin], replay ? [target.DATAFLUX_RUM_WEBGL.webglReplayPlugin()] : [], true) }));
+              if (!accepted_1)
+                throw new Error("Browser RUM is already initialized or did not accept Cocos initialization");
+              this.setContext(this.rum, __assign(__assign({}, (_r = config.sdk) === null || _r === void 0 ? void 0 : _r.globalContext), (_s = config.rum) === null || _s === void 0 ? void 0 : _s.globalContext));
+              this.rum.startView({ name: web.outsideViewName || "CocosInactive" });
+              if (!this.rum.getInitConfiguration())
+                throw new Error("Browser RUM rejected its configuration");
+              this.rum.stopSessionReplayRecording();
+            }
+            if (logsConfig && this.logs) {
+              this.logs.init(logsConfig);
+              if (!this.logs.getInitConfiguration())
+                throw new Error("Browser Logs rejected its configuration");
+              this.setContext(this.logs, __assign(__assign({}, (_t = config.sdk) === null || _t === void 0 ? void 0 : _t.globalContext), (_u = config.logger) === null || _u === void 0 ? void 0 : _u.globalContext));
+            }
+          }
+          FTWebRuntime2.prototype.claim = function(owner) {
+            if (this.owner && this.owner !== owner)
+              throw new Error("Another Cocos facade already owns this page attachment");
+            this.owner = owner;
+          };
+          FTWebRuntime2.prototype.release = function(owner) {
+            if (this.owner !== owner)
+              return;
+            this.stopReplay();
+            this.privacyCheck = void 0;
+            this.owner = void 0;
+          };
+          FTWebRuntime2.prototype.setPrivacyCheck = function(owner, check) {
+            if (this.owner !== owner)
+              throw new Error("Attach the Web SDK before configuring privacy");
+            this.privacyCheck = check;
+          };
+          FTWebRuntime2.prototype.startReplay = function() {
+            if (!this.config.web.replay)
+              throw new Error("Configure Web Replay in the pre-engine bootstrap");
+            this.replayStarted = true;
+            this.rum.startSessionReplayRecording();
+          };
+          FTWebRuntime2.prototype.stopReplay = function() {
+            var _a;
+            if (!this.replayStarted)
+              return;
+            this.replayStarted = false;
+            (_a = this.rum) === null || _a === void 0 ? void 0 : _a.stopSessionReplayRecording();
+          };
+          FTWebRuntime2.prototype.isRecording = function() {
+            var _a;
+            return this.replayStarted && !!((_a = this.rum) === null || _a === void 0 ? void 0 : _a.isRecording());
+          };
+          FTWebRuntime2.prototype.invoke = function(method, input) {
+            var _a, _b, _c, _d;
+            var data = input || {};
+            switch (method) {
+              case "sdk.bindUser": {
+                var user = data;
+                var identity = __assign(__assign({}, user.extra), { id: required(user.userId, "userId"), name: user.userName, email: user.userEmail });
+                (_a = this.rum) === null || _a === void 0 ? void 0 : _a.setUser(identity);
+                (_b = this.logs) === null || _b === void 0 ? void 0 : _b.setUser(identity);
+                break;
+              }
+              case "sdk.unbindUser":
+                (_c = this.rum) === null || _c === void 0 ? void 0 : _c.clearUser();
+                (_d = this.logs) === null || _d === void 0 ? void 0 : _d.clearUser();
+                break;
+              case "rum.startView":
+                this.requireRum().startView({ name: data.name, context: data.attributes });
+                break;
+              case "rum.stopView":
+                this.requireRum().startView({ name: this.config.web.outsideViewName || "CocosInactive", context: data.attributes });
+                break;
+              case "rum.addAction":
+                this.requireRum().addTypeAction(data.name, data.type, data.attributes);
+                break;
+              case "rum.addError": {
+                var error = new Error(data.message);
+                error.name = data.type;
+                error.stack = data.stack;
+                this.requireRum().addError(error, __assign(__assign({}, data.attributes), { cocos_error_state: data.state }));
+                break;
+              }
+              case "logger.log": {
+                if (!this.logs)
+                  throw new Error("Web logging was not enabled");
+                var config = this.config.logger;
+                if (config.enableCustomLog === false || config.logLevelFilters && config.logLevelFilters.indexOf(data.level) < 0)
+                  break;
+                var status_1 = data.level === "warning" ? "warn" : data.level;
+                if (["ok", "debug", "info", "notice", "warn", "error", "critical", "alert", "emerg"].indexOf(status_1) < 0) {
+                  throw new Error("Unsupported Browser log level: ".concat(data.level));
+                }
+                this.logs.logger.log(data.content, data.attributes, status_1);
+                break;
+              }
+              default:
+                throw new Error("".concat(method, " is not supported on Web. Configure collectors at page bootstrap; use Browser automatic network/trace collection and detach() for Cocos cleanup."));
+            }
+            return void 0;
+          };
+          FTWebRuntime2.prototype.requireRum = function() {
+            if (!this.rum)
+              throw new Error("Web RUM was not enabled");
+            return this.rum;
+          };
+          FTWebRuntime2.prototype.setContext = function(api, context) {
+            Object.keys(context).forEach(function(key) {
+              return api.setGlobalContextProperty(key, context[key]);
+            });
+            api.setGlobalContextProperty(version_js_1.FT_COCOS_SDK_VERSION_KEY, version_js_1.FT_COCOS_SDK_VERSION);
+          };
+          return FTWebRuntime2;
+        })()
+      );
+      exports.FTWebRuntime = FTWebRuntime;
+      function bootstrapWeb(config, target) {
+        if (target === void 0) {
+          target = window;
+        }
+        if (target.__FT_COCOS_WEB__)
+          throw new Error("Cocos Web bootstrap already initialized");
+        var runtime = new FTWebRuntime(config, target, true);
+        target.__FT_COCOS_WEB__ = runtime;
+        return runtime;
+      }
+      function required(value, name) {
+        if (typeof value !== "string" || !value.trim())
+          throw new Error("".concat(name, " is required"));
+        return value;
+      }
+      function reportingConnection(web) {
+        if (web.datakitOrigin && (web.site || web.clientToken))
+          throw new Error("Choose datakitOrigin or site with clientToken");
+        var origin = required(web.datakitOrigin || web.site, "web.datakitOrigin or web.site");
+        if (!/^https?:\/\/[^/?#@]+\/?$/.test(origin))
+          throw new Error("Browser reporting endpoint must be an HTTP(S) origin without a path, credentials, query or fragment");
+        return web.datakitOrigin ? { datakitOrigin: origin } : { site: origin, clientToken: required(web.clientToken, "web.clientToken") };
+      }
+      function percentage(value, legacy, fallback, name) {
+        return value !== void 0 ? (0, validation_js_1.samplingPercentage)(value, name) : legacy !== void 0 ? (0, validation_js_1.samplingRate)(legacy, name) * 100 : fallback;
+      }
+      function integer(value, min, max, fallback, name) {
+        if (value === void 0)
+          return fallback;
+        if (!Number.isInteger(value) || value < min || value > max)
+          throw new RangeError("".concat(name, " must be an integer between ").concat(min, " and ").concat(max));
+        return value;
+      }
+    }
+  });
+
+  // packages/cocos/dist/creator2/web/client.js
+  var require_client = __commonJS({
+    "packages/cocos/dist/creator2/web/client.js": function(exports) {
+      "use strict";
+      var __assign = exports && exports.__assign || function() {
+        __assign = Object.assign || function(t) {
+          for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+              t[p] = s[p];
+          }
+          return t;
+        };
+        return __assign.apply(this, arguments);
+      };
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.FTCocosWebSDK = void 0;
+      var modules_js_1 = require_modules();
+      var runtime_js_1 = require_runtime();
+      var FTCocosWebSDK = (
+        /** @class */
+        (function() {
+          function FTCocosWebSDK2(hooks, canvasIsPublic, target, consoleObject) {
+            if (target === void 0) {
+              target = window;
+            }
+            if (consoleObject === void 0) {
+              consoleObject = console;
+            }
+            var _this = this;
+            this.hooks = hooks;
+            this.canvasIsPublic = canvasIsPublic;
+            this.target = target;
+            this.consoleObject = consoleObject;
+            this.platform = "web";
+            this.capabilities = {
+              timedActions: false,
+              manualResourceTiming: false,
+              manualLongTasks: false,
+              manualTraceHeaders: false,
+              shutdown: false,
+              nodeReplayMasks: false
+            };
+            this.tracking = {};
+            this.state = "idle";
+            this.stops = [];
+            this.activeView = false;
+            this.privateNodes = /* @__PURE__ */ new Map();
+            this.replay = {
+              /** Recording settings belong to the pre-engine Web bootstrap. */
+              start: function() {
+                _this.requireRuntime().startReplay();
+              },
+              stop: function() {
+                _this.requireRuntime().stopReplay();
+              },
+              isRecording: function() {
+                var _a;
+                return ((_a = _this.runtime) === null || _a === void 0 ? void 0 : _a.isRecording()) || false;
+              },
+              /** Any protected node blocks the entire Cocos canvas; Browser Replay cannot render node masks. */
+              setPrivacy: function(node, mode) {
+                if (!node)
+                  throw new Error("A Cocos node is required");
+                if (mode === "unmask")
+                  _this.privateNodes.delete(node);
+                else if (mode === "mask" || mode === "hide")
+                  _this.privateNodes.set(node, mode);
+                else
+                  throw new Error("Unknown Replay privacy mode");
+              }
+            };
+            var transport = {
+              platform: "web",
+              invoke: function(method, payload) {
+                return _this.requireRuntime().invoke(method, payload);
+              }
+            };
+            this.mobile = new modules_js_1.FTMobileAgent(transport);
+            this.rum = new modules_js_1.FTRUM(transport);
+            this.logger = new modules_js_1.FTLogger(transport);
+            this.trace = new modules_js_1.FTTrace(transport);
+          }
+          Object.defineProperty(FTCocosWebSDK2.prototype, "lifecycleMode", {
+            get: function() {
+              return this.state === "idle" ? "idle" : this.state === "standalone" ? "standalone" : "hybrid";
+            },
+            enumerable: false,
+            configurable: true
+          });
+          Object.defineProperty(FTCocosWebSDK2.prototype, "isCocosEntered", {
+            get: function() {
+              return this.state === "standalone" || this.state === "entered";
+            },
+            enumerable: false,
+            configurable: true
+          });
+          FTCocosWebSDK2.prototype.start = function(config) {
+            if (this.state !== "idle")
+              throw new Error("Web SDK already started or attached");
+            if (config && "replay" in config)
+              throw new Error("Configure Web Replay at web.replay before engine boot");
+            var runtime = this.target.__FT_COCOS_WEB__;
+            if (runtime) {
+              if (config)
+                assertBootstrapConfiguration(config, runtime.config);
+              this.attach({ autoTrack: config === null || config === void 0 ? void 0 : config.autoTrack });
+            } else {
+              if (!config || !("web" in config))
+                throw new Error("Configure web explicitly or install the pre-engine Web bootstrap");
+              runtime = new runtime_js_1.FTWebRuntime(config, this.target);
+              this.target.__FT_COCOS_WEB__ = runtime;
+              this.bind(runtime, config.autoTrack || {});
+            }
+            this.state = "standalone";
+            try {
+              this.startPage();
+            } catch (error) {
+              try {
+                this.detach();
+              } catch (_a) {
+              }
+              throw error;
+            }
+          };
+          FTCocosWebSDK2.prototype.attach = function(config) {
+            var _a;
+            if (config === void 0) {
+              config = {};
+            }
+            if (this.state === "standalone")
+              throw new Error("start() and attach() are mutually exclusive");
+            if (this.state !== "idle")
+              return;
+            if ("replay" in config)
+              throw new Error("Configure Web Replay at web.replay in the page bootstrap");
+            var runtime = this.target.__FT_COCOS_WEB__;
+            if (!runtime || runtime.protocol !== 1)
+              throw new Error("Run the Cocos Web bootstrap before attach()");
+            if (config.applicationId && config.applicationId !== runtime.config.web.applicationId)
+              throw new Error("Web applicationId does not match page bootstrap");
+            var tracking = __assign(__assign({}, runtime.config.autoTrack), config.autoTrack);
+            for (var _i = 0, _b = ["network", "errors"]; _i < _b.length; _i++) {
+              var key = _b[_i];
+              if (!!tracking[key] !== !!((_a = runtime.config.autoTrack) === null || _a === void 0 ? void 0 : _a[key]))
+                throw new Error("Configure autoTrack.".concat(key, " at page bootstrap"));
+            }
+            this.bind(runtime, tracking);
+            this.state = "attached";
+          };
+          FTCocosWebSDK2.prototype.enterCocos = function(options) {
+            var _a;
+            if (options === void 0) {
+              options = {};
+            }
+            if (this.state === "idle")
+              throw new Error("Call attach() before enterCocos()");
+            if (this.state === "standalone")
+              throw new Error("enterCocos() requires attach()");
+            if (this.state === "entered")
+              return;
+            if (!this.tracking.scenes && !((_a = options.viewName) === null || _a === void 0 ? void 0 : _a.trim()))
+              throw new Error("enterCocos.viewName is required when scene tracking is disabled");
+            try {
+              this.startPage(options.viewName);
+              this.state = "entered";
+            } catch (error) {
+              try {
+                this.stopPage();
+              } catch (_b) {
+              }
+              throw error;
+            }
+          };
+          FTCocosWebSDK2.prototype.leaveCocos = function() {
+            if (this.state === "standalone")
+              throw new Error("Use detach() to stop standalone Cocos instrumentation on Web");
+            if (this.state !== "entered")
+              return;
+            try {
+              this.stopPage();
+            } finally {
+              this.state = "attached";
+            }
+          };
+          FTCocosWebSDK2.prototype.detach = function() {
+            if (this.state === "idle")
+              return;
+            try {
+              this.stopPage();
+            } finally {
+              this.runtime.release(this);
+              this.runtime = void 0;
+              this.state = "idle";
+              this.privateNodes.clear();
+            }
+          };
+          FTCocosWebSDK2.prototype.stop = function() {
+            this.detach();
+          };
+          FTCocosWebSDK2.prototype.shutdown = function() {
+            throw new Error("Browser SDK has no public shutdown API. Use detach() to release Cocos hooks; page collectors continue until unload.");
+          };
+          FTCocosWebSDK2.prototype.setReplayCamera = function(_camera) {
+            throw new Error("Browser Replay captures the configured canvas, not a Cocos camera");
+          };
+          FTCocosWebSDK2.prototype.bind = function(runtime, tracking) {
+            var _this = this;
+            if ((tracking.scenes || tracking.actions || tracking.errors || tracking.network) && !runtime.config.rum)
+              throw new Error("Cocos RUM tracking requires rum configuration");
+            if (tracking.console && !runtime.config.logger)
+              throw new Error("Console tracking requires logger");
+            runtime.claim(this);
+            this.runtime = runtime;
+            this.tracking = tracking;
+            runtime.setPrivacyCheck(this, function() {
+              return _this.privateNodes.size === 0 && _this.canvasIsPublic();
+            });
+          };
+          FTCocosWebSDK2.prototype.startPage = function(viewName) {
+            var _this = this;
+            var view = function(name) {
+              _this.rum.startView(name);
+              _this.activeView = true;
+            };
+            if (viewName)
+              view(viewName);
+            if (this.tracking.scenes)
+              this.stops.push(this.hooks.onSceneChanged(view, !viewName));
+            if (this.tracking.actions)
+              this.stops.push(this.hooks.onAction(function(name, attributes) {
+                return _this.rum.addAction(name, "click", attributes);
+              }));
+            if (this.tracking.console)
+              this.trackConsole();
+            if (this.runtime.config.web.replay)
+              this.runtime.startReplay();
+          };
+          FTCocosWebSDK2.prototype.stopPage = function() {
+            var _this = this;
+            var failure;
+            var clean = function(fn) {
+              try {
+                fn();
+              } catch (error) {
+                if (!failure)
+                  failure = error;
+              }
+            };
+            clean(function() {
+              var _a;
+              return (_a = _this.runtime) === null || _a === void 0 ? void 0 : _a.stopReplay();
+            });
+            this.stops.splice(0).reverse().forEach(clean);
+            if (this.activeView) {
+              clean(function() {
+                return _this.rum.stopView();
+              });
+              this.activeView = false;
+            }
+            if (failure)
+              throw failure;
+          };
+          FTCocosWebSDK2.prototype.requireRuntime = function() {
+            if (!this.runtime)
+              throw new Error("Start or attach the Cocos Web SDK first");
+            return this.runtime;
+          };
+          FTCocosWebSDK2.prototype.trackConsole = function() {
+            var _this = this;
+            ["log", "info", "warn", "error"].forEach(function(method) {
+              var original = _this.consoleObject[method];
+              var wrapped = function() {
+                var values = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                  values[_i] = arguments[_i];
+                }
+                original.apply(_this.consoleObject, values);
+                _this.logger.log(values.map(function(value) {
+                  if (typeof value === "string")
+                    return value;
+                  try {
+                    return JSON.stringify(value);
+                  } catch (_a) {
+                    return String(value);
+                  }
+                }).join(" "), method === "warn" ? "warning" : method === "error" ? "error" : "info");
+              };
+              _this.consoleObject[method] = wrapped;
+              _this.stops.push(function() {
+                if (_this.consoleObject[method] === wrapped)
+                  _this.consoleObject[method] = original;
+              });
+            });
+          };
+          return FTCocosWebSDK2;
+        })()
+      );
+      exports.FTCocosWebSDK = FTCocosWebSDK;
+      function assertBootstrapConfiguration(config, installed) {
+        var shared = {
+          sdk: ["serviceName", "env", "globalContext"],
+          rum: ["sessionSamplingRate", "sampleRate", "sessionOnErrorSamplingRate", "sessionOnErrorSampleRate", "globalContext"],
+          logger: ["logSamplingRate", "sampleRate", "enableCustomLog", "logLevelFilters", "globalContext"],
+          trace: ["traceType", "traceSamplingRate", "sampleRate"],
+          web: Object.keys("web" in config && config.web || {})
+        };
+        Object.keys(shared).forEach(function(group) {
+          var requested = config[group];
+          if (requested === void 0)
+            return;
+          var actual = installed[group];
+          if (actual === void 0)
+            throw new Error("Configure ".concat(group, " in the pre-engine Web bootstrap"));
+          shared[group].forEach(function(key) {
+            if (requested[key] !== void 0 && stableValue(requested[key]) !== stableValue(actual[key])) {
+              throw new Error("Configure ".concat(group, ".").concat(key, " in the pre-engine Web bootstrap; collectors are already initialized"));
+            }
+          });
+        });
+      }
+      function stableValue(value) {
+        return JSON.stringify(value, function(_key, item) {
+          return item && typeof item === "object" && !Array.isArray(item) ? Object.keys(item).sort().reduce(function(result, key) {
+            result[key] = item[key];
+            return result;
+          }, {}) : item;
+        });
+      }
+    }
+  });
+
+  // packages/cocos/dist/creator2/core/platform-runtime.js
+  var require_platform_runtime = __commonJS({
+    "packages/cocos/dist/creator2/core/platform-runtime.js": function(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.platformGlobal = platformGlobal;
+      exports.existingPlatformImplementation = existingPlatformImplementation;
+      exports.platformImplementation = platformImplementation;
+      var version_js_1 = require_version();
+      function platformGlobal() {
+        return typeof window !== "undefined" ? window : globalThis;
+      }
+      function existingPlatformImplementation(context, target) {
+        var _a;
+        if (target === void 0) {
+          target = platformGlobal();
+        }
+        var previous = (_a = target.__FT_COCOS_INSTANCES__) === null || _a === void 0 ? void 0 : _a[context.engine + ":" + context.platform];
+        if (previous && previous.version !== version_js_1.FT_COCOS_SDK_VERSION)
+          throw new Error("Cocos SDK versions must match on the same page");
+        return previous === null || previous === void 0 ? void 0 : previous.sdk;
+      }
+      function platformImplementation(context, target, create) {
+        if (target === void 0) {
+          target = platformGlobal();
+        }
+        var key = context.engine + ":" + context.platform;
+        var instances = target.__FT_COCOS_INSTANCES__ || (target.__FT_COCOS_INSTANCES__ = {});
+        var previous = existingPlatformImplementation(context, target);
+        if (previous)
+          return previous;
+        var factory = context.platform === "web" ? target.__FT_COCOS_WEB_FACTORY__ : target.__FT_COCOS_NATIVE_FACTORY__;
+        if (!create && (!factory || factory.protocol !== 1 || factory.version !== version_js_1.FT_COCOS_SDK_VERSION)) {
+          throw new Error(context.platform === "web" ? "Cocos Web runtime is missing or incompatible. Run the installer with --web and rebuild, or load /web/bootstrap before game scripts." : "Cocos native runtime is missing or incompatible. Rerun the SDK installer and rebuild the project.");
+        }
+        var sdk = create ? create() : factory.create(context, target);
+        instances[key] = { version: version_js_1.FT_COCOS_SDK_VERSION, sdk: sdk };
+        return sdk;
+      }
+    }
+  });
+
+  // packages/cocos/dist/creator2/web/bootstrap.js
+  var require_bootstrap = __commonJS({
+    "packages/cocos/dist/creator2/web/bootstrap.js": function(exports) {
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.bootstrapWeb = void 0;
+      var client_js_1 = require_client();
+      var platform_runtime_js_1 = require_platform_runtime();
+      var version_js_1 = require_version();
+      (0, platform_runtime_js_1.platformGlobal)().__FT_COCOS_WEB_FACTORY__ = {
+        protocol: 1,
+        version: version_js_1.FT_COCOS_SDK_VERSION,
+        create: function(context, target) {
+          return new client_js_1.FTCocosWebSDK(context.hooks, context.canvasIsPublic, target);
+        }
+      };
+      var runtime_js_1 = require_runtime();
+      Object.defineProperty(exports, "bootstrapWeb", { enumerable: true, get: function() {
+        return runtime_js_1.bootstrapWeb;
+      } });
+    }
+  });
+  return require_bootstrap();
+})();
+//# sourceMappingURL=bootstrap.js.map