@squiz/render-runtime-lib 1.71.0 → 1.72.0

package/lib/worker/component-bootstrapper.js

@@ -99276,8 +99276,8 @@ ${originalIndentation}`;
            * @returns {mixed} - TODO: add return description.
            */
           getTrace(err) {
-            const trace = err ? stackTrace.parse(err) : stackTrace.get();
-            return trace.map((site) => {
+            const trace2 = err ? stackTrace.parse(err) : stackTrace.get();
+            return trace2.map((site) => {
               return {
                 column: site.getColumnNumber(),
                 file: site.getFileName(),
@@ -99474,8 +99474,8 @@ ${originalIndentation}`;
            * @returns {mixed} - TODO: add return description.
            */
           getTrace(err) {
-            const trace = err ? stackTrace.parse(err) : stackTrace.get();
-            return trace.map((site) => {
+            const trace2 = err ? stackTrace.parse(err) : stackTrace.get();
+            return trace2.map((site) => {
               return {
                 column: site.getColumnNumber(),
                 file: site.getFileName(),
@@ -105936,6 +105936,1560 @@ ${originalIndentation}`;
         }
       }
     });
+    var require_globalThis = __commonJS2({
+      "../../node_modules/@opentelemetry/api/build/src/platform/node/globalThis.js"(exports3) {
+        "use strict";
+        Object.defineProperty(exports3, "__esModule", { value: true });
+        exports3._globalThis = void 0;
+        exports3._globalThis = typeof globalThis === "object" ? globalThis : global;
+      }
+    });
+    var require_node32 = __commonJS2({
+      "../../node_modules/@opentelemetry/api/build/src/platform/node/index.js"(exports3) {
+        "use strict";
+        var __createBinding62 = exports3 && exports3.__createBinding || (Object.create ? function(o, m, k, k2) {
+          if (k2 === void 0)
+            k2 = k;
+          Object.defineProperty(o, k2, { enumerable: true, get: function() {
+            return m[k];
+          } });
+        } : function(o, m, k, k2) {
+          if (k2 === void 0)
+            k2 = k;
+          o[k2] = m[k];
+        });
+        var __exportStar62 = exports3 && exports3.__exportStar || function(m, exports22) {
+          for (var p in m)
+            if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports22, p))
+              __createBinding62(exports22, m, p);
+        };
+        Object.defineProperty(exports3, "__esModule", { value: true });
+        __exportStar62(require_globalThis(), exports3);
+      }
+    });
+    var require_platform = __commonJS2({
+      "../../node_modules/@opentelemetry/api/build/src/platform/index.js"(exports3) {
+        "use strict";
+        var __createBinding62 = exports3 && exports3.__createBinding || (Object.create ? function(o, m, k, k2) {
+          if (k2 === void 0)
+            k2 = k;
+          Object.defineProperty(o, k2, { enumerable: true, get: function() {
+            return m[k];
+          } });
+        } : function(o, m, k, k2) {
+          if (k2 === void 0)
+            k2 = k;
+          o[k2] = m[k];
+        });
+        var __exportStar62 = exports3 && exports3.__exportStar || function(m, exports22) {
+          for (var p in m)
+            if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports22, p))
+              __createBinding62(exports22, m, p);
+        };
+        Object.defineProperty(exports3, "__esModule", { value: true });
+        __exportStar62(require_node32(), exports3);
+      }
+    });
+    var require_version2 = __commonJS2({
+      "../../node_modules/@opentelemetry/api/build/src/version.js"(exports3) {
+        "use strict";
+        Object.defineProperty(exports3, "__esModule", { value: true });
+        exports3.VERSION = void 0;
+        exports3.VERSION = "1.6.0";
+      }
+    });
+    var require_semver3 = __commonJS2({
+      "../../node_modules/@opentelemetry/api/build/src/internal/semver.js"(exports3) {
+        "use strict";
+        Object.defineProperty(exports3, "__esModule", { value: true });
+        exports3.isCompatible = exports3._makeCompatibilityCheck = void 0;
+        var version_1 = require_version2();
+        var re = /^(\d+)\.(\d+)\.(\d+)(-(.+))?$/;
+        function _makeCompatibilityCheck(ownVersion) {
+          const acceptedVersions = /* @__PURE__ */ new Set([ownVersion]);
+          const rejectedVersions = /* @__PURE__ */ new Set();
+          const myVersionMatch = ownVersion.match(re);
+          if (!myVersionMatch) {
+            return () => false;
+          }
+          const ownVersionParsed = {
+            major: +myVersionMatch[1],
+            minor: +myVersionMatch[2],
+            patch: +myVersionMatch[3],
+            prerelease: myVersionMatch[4]
+          };
+          if (ownVersionParsed.prerelease != null) {
+            return function isExactmatch(globalVersion) {
+              return globalVersion === ownVersion;
+            };
+          }
+          function _reject(v) {
+            rejectedVersions.add(v);
+            return false;
+          }
+          function _accept(v) {
+            acceptedVersions.add(v);
+            return true;
+          }
+          return function isCompatible(globalVersion) {
+            if (acceptedVersions.has(globalVersion)) {
+              return true;
+            }
+            if (rejectedVersions.has(globalVersion)) {
+              return false;
+            }
+            const globalVersionMatch = globalVersion.match(re);
+            if (!globalVersionMatch) {
+              return _reject(globalVersion);
+            }
+            const globalVersionParsed = {
+              major: +globalVersionMatch[1],
+              minor: +globalVersionMatch[2],
+              patch: +globalVersionMatch[3],
+              prerelease: globalVersionMatch[4]
+            };
+            if (globalVersionParsed.prerelease != null) {
+              return _reject(globalVersion);
+            }
+            if (ownVersionParsed.major !== globalVersionParsed.major) {
+              return _reject(globalVersion);
+            }
+            if (ownVersionParsed.major === 0) {
+              if (ownVersionParsed.minor === globalVersionParsed.minor && ownVersionParsed.patch <= globalVersionParsed.patch) {
+                return _accept(globalVersion);
+              }
+              return _reject(globalVersion);
+            }
+            if (ownVersionParsed.minor <= globalVersionParsed.minor) {
+              return _accept(globalVersion);
+            }
+            return _reject(globalVersion);
+          };
+        }
+        exports3._makeCompatibilityCheck = _makeCompatibilityCheck;
+        exports3.isCompatible = _makeCompatibilityCheck(version_1.VERSION);
+      }
+    });
+    var require_global_utils = __commonJS2({
+      "../../node_modules/@opentelemetry/api/build/src/internal/global-utils.js"(exports3) {
+        "use strict";
+        Object.defineProperty(exports3, "__esModule", { value: true });
+        exports3.unregisterGlobal = exports3.getGlobal = exports3.registerGlobal = void 0;
+        var platform_1 = require_platform();
+        var version_1 = require_version2();
+        var semver_1 = require_semver3();
+        var major = version_1.VERSION.split(".")[0];
+        var GLOBAL_OPENTELEMETRY_API_KEY = Symbol.for(`opentelemetry.js.api.${major}`);
+        var _global = platform_1._globalThis;
+        function registerGlobal(type2, instance, diag, allowOverride = false) {
+          var _a;
+          const api = _global[GLOBAL_OPENTELEMETRY_API_KEY] = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) !== null && _a !== void 0 ? _a : {
+            version: version_1.VERSION
+          };
+          if (!allowOverride && api[type2]) {
+            const err = new Error(`@opentelemetry/api: Attempted duplicate registration of API: ${type2}`);
+            diag.error(err.stack || err.message);
+            return false;
+          }
+          if (api.version !== version_1.VERSION) {
+            const err = new Error(`@opentelemetry/api: Registration of version v${api.version} for ${type2} does not match previously registered API v${version_1.VERSION}`);
+            diag.error(err.stack || err.message);
+            return false;
+          }
+          api[type2] = instance;
+          diag.debug(`@opentelemetry/api: Registered a global for ${type2} v${version_1.VERSION}.`);
+          return true;
+        }
+        exports3.registerGlobal = registerGlobal;
+        function getGlobal(type2) {
+          var _a, _b;
+          const globalVersion = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _a === void 0 ? void 0 : _a.version;
+          if (!globalVersion || !(0, semver_1.isCompatible)(globalVersion)) {
+            return;
+          }
+          return (_b = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _b === void 0 ? void 0 : _b[type2];
+        }
+        exports3.getGlobal = getGlobal;
+        function unregisterGlobal(type2, diag) {
+          diag.debug(`@opentelemetry/api: Unregistering a global for ${type2} v${version_1.VERSION}.`);
+          const api = _global[GLOBAL_OPENTELEMETRY_API_KEY];
+          if (api) {
+            delete api[type2];
+          }
+        }
+        exports3.unregisterGlobal = unregisterGlobal;
+      }
+    });
+    var require_ComponentLogger = __commonJS2({
+      "../../node_modules/@opentelemetry/api/build/src/diag/ComponentLogger.js"(exports3) {
+        "use strict";
+        Object.defineProperty(exports3, "__esModule", { value: true });
+        exports3.DiagComponentLogger = void 0;
+        var global_utils_1 = require_global_utils();
+        var DiagComponentLogger = class {
+          constructor(props) {
+            this._namespace = props.namespace || "DiagComponentLogger";
+          }
+          debug(...args) {
+            return logProxy("debug", this._namespace, args);
+          }
+          error(...args) {
+            return logProxy("error", this._namespace, args);
+          }
+          info(...args) {
+            return logProxy("info", this._namespace, args);
+          }
+          warn(...args) {
+            return logProxy("warn", this._namespace, args);
+          }
+          verbose(...args) {
+            return logProxy("verbose", this._namespace, args);
+          }
+        };
+        exports3.DiagComponentLogger = DiagComponentLogger;
+        function logProxy(funcName, namespace, args) {
+          const logger2 = (0, global_utils_1.getGlobal)("diag");
+          if (!logger2) {
+            return;
+          }
+          args.unshift(namespace);
+          return logger2[funcName](...args);
+        }
+      }
+    });
+    var require_types = __commonJS2({
+      "../../node_modules/@opentelemetry/api/build/src/diag/types.js"(exports3) {
+        "use strict";
+        Object.defineProperty(exports3, "__esModule", { value: true });
+        exports3.DiagLogLevel = void 0;
+        var DiagLogLevel;
+        (function(DiagLogLevel2) {
+          DiagLogLevel2[DiagLogLevel2["NONE"] = 0] = "NONE";
+          DiagLogLevel2[DiagLogLevel2["ERROR"] = 30] = "ERROR";
+          DiagLogLevel2[DiagLogLevel2["WARN"] = 50] = "WARN";
+          DiagLogLevel2[DiagLogLevel2["INFO"] = 60] = "INFO";
+          DiagLogLevel2[DiagLogLevel2["DEBUG"] = 70] = "DEBUG";
+          DiagLogLevel2[DiagLogLevel2["VERBOSE"] = 80] = "VERBOSE";
+          DiagLogLevel2[DiagLogLevel2["ALL"] = 9999] = "ALL";
+        })(DiagLogLevel = exports3.DiagLogLevel || (exports3.DiagLogLevel = {}));
+      }
+    });
+    var require_logLevelLogger = __commonJS2({
+      "../../node_modules/@opentelemetry/api/build/src/diag/internal/logLevelLogger.js"(exports3) {
+        "use strict";
+        Object.defineProperty(exports3, "__esModule", { value: true });
+        exports3.createLogLevelDiagLogger = void 0;
+        var types_1 = require_types();
+        function createLogLevelDiagLogger(maxLevel, logger2) {
+          if (maxLevel < types_1.DiagLogLevel.NONE) {
+            maxLevel = types_1.DiagLogLevel.NONE;
+          } else if (maxLevel > types_1.DiagLogLevel.ALL) {
+            maxLevel = types_1.DiagLogLevel.ALL;
+          }
+          logger2 = logger2 || {};
+          function _filterFunc(funcName, theLevel) {
+            const theFunc = logger2[funcName];
+            if (typeof theFunc === "function" && maxLevel >= theLevel) {
+              return theFunc.bind(logger2);
+            }
+            return function() {
+            };
+          }
+          return {
+            error: _filterFunc("error", types_1.DiagLogLevel.ERROR),
+            warn: _filterFunc("warn", types_1.DiagLogLevel.WARN),
+            info: _filterFunc("info", types_1.DiagLogLevel.INFO),
+            debug: _filterFunc("debug", types_1.DiagLogLevel.DEBUG),
+            verbose: _filterFunc("verbose", types_1.DiagLogLevel.VERBOSE)
+          };
+        }
+        exports3.createLogLevelDiagLogger = createLogLevelDiagLogger;
+      }
+    });
+    var require_diag = __commonJS2({
+      "../../node_modules/@opentelemetry/api/build/src/api/diag.js"(exports3) {
+        "use strict";
+        Object.defineProperty(exports3, "__esModule", { value: true });
+        exports3.DiagAPI = void 0;
+        var ComponentLogger_1 = require_ComponentLogger();
+        var logLevelLogger_1 = require_logLevelLogger();
+        var types_1 = require_types();
+        var global_utils_1 = require_global_utils();
+        var API_NAME = "diag";
+        var DiagAPI = class {
+          /**
+           * Private internal constructor
+           * @private
+           */
+          constructor() {
+            function _logProxy(funcName) {
+              return function(...args) {
+                const logger2 = (0, global_utils_1.getGlobal)("diag");
+                if (!logger2)
+                  return;
+                return logger2[funcName](...args);
+              };
+            }
+            const self2 = this;
+            const setLogger = (logger2, optionsOrLogLevel = { logLevel: types_1.DiagLogLevel.INFO }) => {
+              var _a, _b, _c;
+              if (logger2 === self2) {
+                const err = new Error("Cannot use diag as the logger for itself. Please use a DiagLogger implementation like ConsoleDiagLogger or a custom implementation");
+                self2.error((_a = err.stack) !== null && _a !== void 0 ? _a : err.message);
+                return false;
+              }
+              if (typeof optionsOrLogLevel === "number") {
+                optionsOrLogLevel = {
+                  logLevel: optionsOrLogLevel
+                };
+              }
+              const oldLogger = (0, global_utils_1.getGlobal)("diag");
+              const newLogger = (0, logLevelLogger_1.createLogLevelDiagLogger)((_b = optionsOrLogLevel.logLevel) !== null && _b !== void 0 ? _b : types_1.DiagLogLevel.INFO, logger2);
+              if (oldLogger && !optionsOrLogLevel.suppressOverrideMessage) {
+                const stack = (_c = new Error().stack) !== null && _c !== void 0 ? _c : "<failed to generate stacktrace>";
+                oldLogger.warn(`Current logger will be overwritten from ${stack}`);
+                newLogger.warn(`Current logger will overwrite one already registered from ${stack}`);
+              }
+              return (0, global_utils_1.registerGlobal)("diag", newLogger, self2, true);
+            };
+            self2.setLogger = setLogger;
+            self2.disable = () => {
+              (0, global_utils_1.unregisterGlobal)(API_NAME, self2);
+            };
+            self2.createComponentLogger = (options) => {
+              return new ComponentLogger_1.DiagComponentLogger(options);
+            };
+            self2.verbose = _logProxy("verbose");
+            self2.debug = _logProxy("debug");
+            self2.info = _logProxy("info");
+            self2.warn = _logProxy("warn");
+            self2.error = _logProxy("error");
+          }
+          /** Get the singleton instance of the DiagAPI API */
+          static instance() {
+            if (!this._instance) {
+              this._instance = new DiagAPI();
+            }
+            return this._instance;
+          }
+        };
+        exports3.DiagAPI = DiagAPI;
+      }
+    });
+    var require_baggage_impl = __commonJS2({
+      "../../node_modules/@opentelemetry/api/build/src/baggage/internal/baggage-impl.js"(exports3) {
+        "use strict";
+        Object.defineProperty(exports3, "__esModule", { value: true });
+        exports3.BaggageImpl = void 0;
+        var BaggageImpl = class {
+          constructor(entries) {
+            this._entries = entries ? new Map(entries) : /* @__PURE__ */ new Map();
+          }
+          getEntry(key) {
+            const entry = this._entries.get(key);
+            if (!entry) {
+              return void 0;
+            }
+            return Object.assign({}, entry);
+          }
+          getAllEntries() {
+            return Array.from(this._entries.entries()).map(([k, v]) => [k, v]);
+          }
+          setEntry(key, entry) {
+            const newBaggage = new BaggageImpl(this._entries);
+            newBaggage._entries.set(key, entry);
+            return newBaggage;
+          }
+          removeEntry(key) {
+            const newBaggage = new BaggageImpl(this._entries);
+            newBaggage._entries.delete(key);
+            return newBaggage;
+          }
+          removeEntries(...keys) {
+            const newBaggage = new BaggageImpl(this._entries);
+            for (const key of keys) {
+              newBaggage._entries.delete(key);
+            }
+            return newBaggage;
+          }
+          clear() {
+            return new BaggageImpl();
+          }
+        };
+        exports3.BaggageImpl = BaggageImpl;
+      }
+    });
+    var require_symbol = __commonJS2({
+      "../../node_modules/@opentelemetry/api/build/src/baggage/internal/symbol.js"(exports3) {
+        "use strict";
+        Object.defineProperty(exports3, "__esModule", { value: true });
+        exports3.baggageEntryMetadataSymbol = void 0;
+        exports3.baggageEntryMetadataSymbol = Symbol("BaggageEntryMetadata");
+      }
+    });
+    var require_utils42 = __commonJS2({
+      "../../node_modules/@opentelemetry/api/build/src/baggage/utils.js"(exports3) {
+        "use strict";
+        Object.defineProperty(exports3, "__esModule", { value: true });
+        exports3.baggageEntryMetadataFromString = exports3.createBaggage = void 0;
+        var diag_1 = require_diag();
+        var baggage_impl_1 = require_baggage_impl();
+        var symbol_1 = require_symbol();
+        var diag = diag_1.DiagAPI.instance();
+        function createBaggage(entries = {}) {
+          return new baggage_impl_1.BaggageImpl(new Map(Object.entries(entries)));
+        }
+        exports3.createBaggage = createBaggage;
+        function baggageEntryMetadataFromString(str) {
+          if (typeof str !== "string") {
+            diag.error(`Cannot create baggage metadata from unknown type: ${typeof str}`);
+            str = "";
+          }
+          return {
+            __TYPE__: symbol_1.baggageEntryMetadataSymbol,
+            toString() {
+              return str;
+            }
+          };
+        }
+        exports3.baggageEntryMetadataFromString = baggageEntryMetadataFromString;
+      }
+    });
+    var require_context2 = __commonJS2({
+      "../../node_modules/@opentelemetry/api/build/src/context/context.js"(exports3) {
+        "use strict";
+        Object.defineProperty(exports3, "__esModule", { value: true });
+        exports3.ROOT_CONTEXT = exports3.createContextKey = void 0;
+        function createContextKey(description) {
+          return Symbol.for(description);
+        }
+        exports3.createContextKey = createContextKey;
+        var BaseContext = class {
+          /**
+           * Construct a new context which inherits values from an optional parent context.
+           *
+           * @param parentContext a context from which to inherit values
+           */
+          constructor(parentContext) {
+            const self2 = this;
+            self2._currentContext = parentContext ? new Map(parentContext) : /* @__PURE__ */ new Map();
+            self2.getValue = (key) => self2._currentContext.get(key);
+            self2.setValue = (key, value) => {
+              const context = new BaseContext(self2._currentContext);
+              context._currentContext.set(key, value);
+              return context;
+            };
+            self2.deleteValue = (key) => {
+              const context = new BaseContext(self2._currentContext);
+              context._currentContext.delete(key);
+              return context;
+            };
+          }
+        };
+        exports3.ROOT_CONTEXT = new BaseContext();
+      }
+    });
+    var require_consoleLogger = __commonJS2({
+      "../../node_modules/@opentelemetry/api/build/src/diag/consoleLogger.js"(exports3) {
+        "use strict";
+        Object.defineProperty(exports3, "__esModule", { value: true });
+        exports3.DiagConsoleLogger = void 0;
+        var consoleMap = [
+          { n: "error", c: "error" },
+          { n: "warn", c: "warn" },
+          { n: "info", c: "info" },
+          { n: "debug", c: "debug" },
+          { n: "verbose", c: "trace" }
+        ];
+        var DiagConsoleLogger = class {
+          constructor() {
+            function _consoleFunc(funcName) {
+              return function(...args) {
+                if (console) {
+                  let theFunc = console[funcName];
+                  if (typeof theFunc !== "function") {
+                    theFunc = console.log;
+                  }
+                  if (typeof theFunc === "function") {
+                    return theFunc.apply(console, args);
+                  }
+                }
+              };
+            }
+            for (let i = 0; i < consoleMap.length; i++) {
+              this[consoleMap[i].n] = _consoleFunc(consoleMap[i].c);
+            }
+          }
+        };
+        exports3.DiagConsoleLogger = DiagConsoleLogger;
+      }
+    });
+    var require_NoopMeter = __commonJS2({
+      "../../node_modules/@opentelemetry/api/build/src/metrics/NoopMeter.js"(exports3) {
+        "use strict";
+        Object.defineProperty(exports3, "__esModule", { value: true });
+        exports3.createNoopMeter = exports3.NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC = exports3.NOOP_OBSERVABLE_GAUGE_METRIC = exports3.NOOP_OBSERVABLE_COUNTER_METRIC = exports3.NOOP_UP_DOWN_COUNTER_METRIC = exports3.NOOP_HISTOGRAM_METRIC = exports3.NOOP_COUNTER_METRIC = exports3.NOOP_METER = exports3.NoopObservableUpDownCounterMetric = exports3.NoopObservableGaugeMetric = exports3.NoopObservableCounterMetric = exports3.NoopObservableMetric = exports3.NoopHistogramMetric = exports3.NoopUpDownCounterMetric = exports3.NoopCounterMetric = exports3.NoopMetric = exports3.NoopMeter = void 0;
+        var NoopMeter = class {
+          constructor() {
+          }
+          /**
+           * @see {@link Meter.createHistogram}
+           */
+          createHistogram(_name, _options) {
+            return exports3.NOOP_HISTOGRAM_METRIC;
+          }
+          /**
+           * @see {@link Meter.createCounter}
+           */
+          createCounter(_name, _options) {
+            return exports3.NOOP_COUNTER_METRIC;
+          }
+          /**
+           * @see {@link Meter.createUpDownCounter}
+           */
+          createUpDownCounter(_name, _options) {
+            return exports3.NOOP_UP_DOWN_COUNTER_METRIC;
+          }
+          /**
+           * @see {@link Meter.createObservableGauge}
+           */
+          createObservableGauge(_name, _options) {
+            return exports3.NOOP_OBSERVABLE_GAUGE_METRIC;
+          }
+          /**
+           * @see {@link Meter.createObservableCounter}
+           */
+          createObservableCounter(_name, _options) {
+            return exports3.NOOP_OBSERVABLE_COUNTER_METRIC;
+          }
+          /**
+           * @see {@link Meter.createObservableUpDownCounter}
+           */
+          createObservableUpDownCounter(_name, _options) {
+            return exports3.NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC;
+          }
+          /**
+           * @see {@link Meter.addBatchObservableCallback}
+           */
+          addBatchObservableCallback(_callback, _observables) {
+          }
+          /**
+           * @see {@link Meter.removeBatchObservableCallback}
+           */
+          removeBatchObservableCallback(_callback) {
+          }
+        };
+        exports3.NoopMeter = NoopMeter;
+        var NoopMetric = class {
+        };
+        exports3.NoopMetric = NoopMetric;
+        var NoopCounterMetric = class extends NoopMetric {
+          add(_value, _attributes) {
+          }
+        };
+        exports3.NoopCounterMetric = NoopCounterMetric;
+        var NoopUpDownCounterMetric = class extends NoopMetric {
+          add(_value, _attributes) {
+          }
+        };
+        exports3.NoopUpDownCounterMetric = NoopUpDownCounterMetric;
+        var NoopHistogramMetric = class extends NoopMetric {
+          record(_value, _attributes) {
+          }
+        };
+        exports3.NoopHistogramMetric = NoopHistogramMetric;
+        var NoopObservableMetric = class {
+          addCallback(_callback) {
+          }
+          removeCallback(_callback) {
+          }
+        };
+        exports3.NoopObservableMetric = NoopObservableMetric;
+        var NoopObservableCounterMetric = class extends NoopObservableMetric {
+        };
+        exports3.NoopObservableCounterMetric = NoopObservableCounterMetric;
+        var NoopObservableGaugeMetric = class extends NoopObservableMetric {
+        };
+        exports3.NoopObservableGaugeMetric = NoopObservableGaugeMetric;
+        var NoopObservableUpDownCounterMetric = class extends NoopObservableMetric {
+        };
+        exports3.NoopObservableUpDownCounterMetric = NoopObservableUpDownCounterMetric;
+        exports3.NOOP_METER = new NoopMeter();
+        exports3.NOOP_COUNTER_METRIC = new NoopCounterMetric();
+        exports3.NOOP_HISTOGRAM_METRIC = new NoopHistogramMetric();
+        exports3.NOOP_UP_DOWN_COUNTER_METRIC = new NoopUpDownCounterMetric();
+        exports3.NOOP_OBSERVABLE_COUNTER_METRIC = new NoopObservableCounterMetric();
+        exports3.NOOP_OBSERVABLE_GAUGE_METRIC = new NoopObservableGaugeMetric();
+        exports3.NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC = new NoopObservableUpDownCounterMetric();
+        function createNoopMeter() {
+          return exports3.NOOP_METER;
+        }
+        exports3.createNoopMeter = createNoopMeter;
+      }
+    });
+    var require_Metric = __commonJS2({
+      "../../node_modules/@opentelemetry/api/build/src/metrics/Metric.js"(exports3) {
+        "use strict";
+        Object.defineProperty(exports3, "__esModule", { value: true });
+        exports3.ValueType = void 0;
+        var ValueType;
+        (function(ValueType2) {
+          ValueType2[ValueType2["INT"] = 0] = "INT";
+          ValueType2[ValueType2["DOUBLE"] = 1] = "DOUBLE";
+        })(ValueType = exports3.ValueType || (exports3.ValueType = {}));
+      }
+    });
+    var require_TextMapPropagator = __commonJS2({
+      "../../node_modules/@opentelemetry/api/build/src/propagation/TextMapPropagator.js"(exports3) {
+        "use strict";
+        Object.defineProperty(exports3, "__esModule", { value: true });
+        exports3.defaultTextMapSetter = exports3.defaultTextMapGetter = void 0;
+        exports3.defaultTextMapGetter = {
+          get(carrier, key) {
+            if (carrier == null) {
+              return void 0;
+            }
+            return carrier[key];
+          },
+          keys(carrier) {
+            if (carrier == null) {
+              return [];
+            }
+            return Object.keys(carrier);
+          }
+        };
+        exports3.defaultTextMapSetter = {
+          set(carrier, key, value) {
+            if (carrier == null) {
+              return;
+            }
+            carrier[key] = value;
+          }
+        };
+      }
+    });
+    var require_NoopContextManager = __commonJS2({
+      "../../node_modules/@opentelemetry/api/build/src/context/NoopContextManager.js"(exports3) {
+        "use strict";
+        Object.defineProperty(exports3, "__esModule", { value: true });
+        exports3.NoopContextManager = void 0;
+        var context_1 = require_context2();
+        var NoopContextManager = class {
+          active() {
+            return context_1.ROOT_CONTEXT;
+          }
+          with(_context, fn, thisArg, ...args) {
+            return fn.call(thisArg, ...args);
+          }
+          bind(_context, target2) {
+            return target2;
+          }
+          enable() {
+            return this;
+          }
+          disable() {
+            return this;
+          }
+        };
+        exports3.NoopContextManager = NoopContextManager;
+      }
+    });
+    var require_context22 = __commonJS2({
+      "../../node_modules/@opentelemetry/api/build/src/api/context.js"(exports3) {
+        "use strict";
+        Object.defineProperty(exports3, "__esModule", { value: true });
+        exports3.ContextAPI = void 0;
+        var NoopContextManager_1 = require_NoopContextManager();
+        var global_utils_1 = require_global_utils();
+        var diag_1 = require_diag();
+        var API_NAME = "context";
+        var NOOP_CONTEXT_MANAGER = new NoopContextManager_1.NoopContextManager();
+        var ContextAPI = class {
+          /** Empty private constructor prevents end users from constructing a new instance of the API */
+          constructor() {
+          }
+          /** Get the singleton instance of the Context API */
+          static getInstance() {
+            if (!this._instance) {
+              this._instance = new ContextAPI();
+            }
+            return this._instance;
+          }
+          /**
+           * Set the current context manager.
+           *
+           * @returns true if the context manager was successfully registered, else false
+           */
+          setGlobalContextManager(contextManager) {
+            return (0, global_utils_1.registerGlobal)(API_NAME, contextManager, diag_1.DiagAPI.instance());
+          }
+          /**
+           * Get the currently active context
+           */
+          active() {
+            return this._getContextManager().active();
+          }
+          /**
+           * Execute a function with an active context
+           *
+           * @param context context to be active during function execution
+           * @param fn function to execute in a context
+           * @param thisArg optional receiver to be used for calling fn
+           * @param args optional arguments forwarded to fn
+           */
+          with(context, fn, thisArg, ...args) {
+            return this._getContextManager().with(context, fn, thisArg, ...args);
+          }
+          /**
+           * Bind a context to a target function or event emitter
+           *
+           * @param context context to bind to the event emitter or function. Defaults to the currently active context
+           * @param target function or event emitter to bind
+           */
+          bind(context, target2) {
+            return this._getContextManager().bind(context, target2);
+          }
+          _getContextManager() {
+            return (0, global_utils_1.getGlobal)(API_NAME) || NOOP_CONTEXT_MANAGER;
+          }
+          /** Disable and remove the global context manager */
+          disable() {
+            this._getContextManager().disable();
+            (0, global_utils_1.unregisterGlobal)(API_NAME, diag_1.DiagAPI.instance());
+          }
+        };
+        exports3.ContextAPI = ContextAPI;
+      }
+    });
+    var require_trace_flags = __commonJS2({
+      "../../node_modules/@opentelemetry/api/build/src/trace/trace_flags.js"(exports3) {
+        "use strict";
+        Object.defineProperty(exports3, "__esModule", { value: true });
+        exports3.TraceFlags = void 0;
+        var TraceFlags;
+        (function(TraceFlags2) {
+          TraceFlags2[TraceFlags2["NONE"] = 0] = "NONE";
+          TraceFlags2[TraceFlags2["SAMPLED"] = 1] = "SAMPLED";
+        })(TraceFlags = exports3.TraceFlags || (exports3.TraceFlags = {}));
+      }
+    });
+    var require_invalid_span_constants = __commonJS2({
+      "../../node_modules/@opentelemetry/api/build/src/trace/invalid-span-constants.js"(exports3) {
+        "use strict";
+        Object.defineProperty(exports3, "__esModule", { value: true });
+        exports3.INVALID_SPAN_CONTEXT = exports3.INVALID_TRACEID = exports3.INVALID_SPANID = void 0;
+        var trace_flags_1 = require_trace_flags();
+        exports3.INVALID_SPANID = "0000000000000000";
+        exports3.INVALID_TRACEID = "00000000000000000000000000000000";
+        exports3.INVALID_SPAN_CONTEXT = {
+          traceId: exports3.INVALID_TRACEID,
+          spanId: exports3.INVALID_SPANID,
+          traceFlags: trace_flags_1.TraceFlags.NONE
+        };
+      }
+    });
+    var require_NonRecordingSpan = __commonJS2({
+      "../../node_modules/@opentelemetry/api/build/src/trace/NonRecordingSpan.js"(exports3) {
+        "use strict";
+        Object.defineProperty(exports3, "__esModule", { value: true });
+        exports3.NonRecordingSpan = void 0;
+        var invalid_span_constants_1 = require_invalid_span_constants();
+        var NonRecordingSpan = class {
+          constructor(_spanContext = invalid_span_constants_1.INVALID_SPAN_CONTEXT) {
+            this._spanContext = _spanContext;
+          }
+          // Returns a SpanContext.
+          spanContext() {
+            return this._spanContext;
+          }
+          // By default does nothing
+          setAttribute(_key, _value) {
+            return this;
+          }
+          // By default does nothing
+          setAttributes(_attributes) {
+            return this;
+          }
+          // By default does nothing
+          addEvent(_name, _attributes) {
+            return this;
+          }
+          // By default does nothing
+          setStatus(_status) {
+            return this;
+          }
+          // By default does nothing
+          updateName(_name) {
+            return this;
+          }
+          // By default does nothing
+          end(_endTime) {
+          }
+          // isRecording always returns false for NonRecordingSpan.
+          isRecording() {
+            return false;
+          }
+          // By default does nothing
+          recordException(_exception, _time) {
+          }
+        };
+        exports3.NonRecordingSpan = NonRecordingSpan;
+      }
+    });
+    var require_context_utils = __commonJS2({
+      "../../node_modules/@opentelemetry/api/build/src/trace/context-utils.js"(exports3) {
+        "use strict";
+        Object.defineProperty(exports3, "__esModule", { value: true });
+        exports3.getSpanContext = exports3.setSpanContext = exports3.deleteSpan = exports3.setSpan = exports3.getActiveSpan = exports3.getSpan = void 0;
+        var context_1 = require_context2();
+        var NonRecordingSpan_1 = require_NonRecordingSpan();
+        var context_2 = require_context22();
+        var SPAN_KEY = (0, context_1.createContextKey)("OpenTelemetry Context Key SPAN");
+        function getSpan(context) {
+          return context.getValue(SPAN_KEY) || void 0;
+        }
+        exports3.getSpan = getSpan;
+        function getActiveSpan() {
+          return getSpan(context_2.ContextAPI.getInstance().active());
+        }
+        exports3.getActiveSpan = getActiveSpan;
+        function setSpan(context, span) {
+          return context.setValue(SPAN_KEY, span);
+        }
+        exports3.setSpan = setSpan;
+        function deleteSpan(context) {
+          return context.deleteValue(SPAN_KEY);
+        }
+        exports3.deleteSpan = deleteSpan;
+        function setSpanContext(context, spanContext) {
+          return setSpan(context, new NonRecordingSpan_1.NonRecordingSpan(spanContext));
+        }
+        exports3.setSpanContext = setSpanContext;
+        function getSpanContext(context) {
+          var _a;
+          return (_a = getSpan(context)) === null || _a === void 0 ? void 0 : _a.spanContext();
+        }
+        exports3.getSpanContext = getSpanContext;
+      }
+    });
+    var require_spancontext_utils = __commonJS2({
+      "../../node_modules/@opentelemetry/api/build/src/trace/spancontext-utils.js"(exports3) {
+        "use strict";
+        Object.defineProperty(exports3, "__esModule", { value: true });
+        exports3.wrapSpanContext = exports3.isSpanContextValid = exports3.isValidSpanId = exports3.isValidTraceId = void 0;
+        var invalid_span_constants_1 = require_invalid_span_constants();
+        var NonRecordingSpan_1 = require_NonRecordingSpan();
+        var VALID_TRACEID_REGEX = /^([0-9a-f]{32})$/i;
+        var VALID_SPANID_REGEX = /^[0-9a-f]{16}$/i;
+        function isValidTraceId(traceId) {
+          return VALID_TRACEID_REGEX.test(traceId) && traceId !== invalid_span_constants_1.INVALID_TRACEID;
+        }
+        exports3.isValidTraceId = isValidTraceId;
+        function isValidSpanId(spanId) {
+          return VALID_SPANID_REGEX.test(spanId) && spanId !== invalid_span_constants_1.INVALID_SPANID;
+        }
+        exports3.isValidSpanId = isValidSpanId;
+        function isSpanContextValid(spanContext) {
+          return isValidTraceId(spanContext.traceId) && isValidSpanId(spanContext.spanId);
+        }
+        exports3.isSpanContextValid = isSpanContextValid;
+        function wrapSpanContext(spanContext) {
+          return new NonRecordingSpan_1.NonRecordingSpan(spanContext);
+        }
+        exports3.wrapSpanContext = wrapSpanContext;
+      }
+    });
+    var require_NoopTracer = __commonJS2({
+      "../../node_modules/@opentelemetry/api/build/src/trace/NoopTracer.js"(exports3) {
+        "use strict";
+        Object.defineProperty(exports3, "__esModule", { value: true });
+        exports3.NoopTracer = void 0;
+        var context_1 = require_context22();
+        var context_utils_1 = require_context_utils();
+        var NonRecordingSpan_1 = require_NonRecordingSpan();
+        var spancontext_utils_1 = require_spancontext_utils();
+        var contextApi = context_1.ContextAPI.getInstance();
+        var NoopTracer = class {
+          // startSpan starts a noop span.
+          startSpan(name, options, context = contextApi.active()) {
+            const root = Boolean(options === null || options === void 0 ? void 0 : options.root);
+            if (root) {
+              return new NonRecordingSpan_1.NonRecordingSpan();
+            }
+            const parentFromContext = context && (0, context_utils_1.getSpanContext)(context);
+            if (isSpanContext(parentFromContext) && (0, spancontext_utils_1.isSpanContextValid)(parentFromContext)) {
+              return new NonRecordingSpan_1.NonRecordingSpan(parentFromContext);
+            } else {
+              return new NonRecordingSpan_1.NonRecordingSpan();
+            }
+          }
+          startActiveSpan(name, arg2, arg3, arg4) {
+            let opts;
+            let ctx;
+            let fn;
+            if (arguments.length < 2) {
+              return;
+            } else if (arguments.length === 2) {
+              fn = arg2;
+            } else if (arguments.length === 3) {
+              opts = arg2;
+              fn = arg3;
+            } else {
+              opts = arg2;
+              ctx = arg3;
+              fn = arg4;
+            }
+            const parentContext = ctx !== null && ctx !== void 0 ? ctx : contextApi.active();
+            const span = this.startSpan(name, opts, parentContext);
+            const contextWithSpanSet = (0, context_utils_1.setSpan)(parentContext, span);
+            return contextApi.with(contextWithSpanSet, fn, void 0, span);
+          }
+        };
+        exports3.NoopTracer = NoopTracer;
+        function isSpanContext(spanContext) {
+          return typeof spanContext === "object" && typeof spanContext["spanId"] === "string" && typeof spanContext["traceId"] === "string" && typeof spanContext["traceFlags"] === "number";
+        }
+      }
+    });
+    var require_ProxyTracer = __commonJS2({
+      "../../node_modules/@opentelemetry/api/build/src/trace/ProxyTracer.js"(exports3) {
+        "use strict";
+        Object.defineProperty(exports3, "__esModule", { value: true });
+        exports3.ProxyTracer = void 0;
+        var NoopTracer_1 = require_NoopTracer();
+        var NOOP_TRACER = new NoopTracer_1.NoopTracer();
+        var ProxyTracer = class {
+          constructor(_provider, name, version32, options) {
+            this._provider = _provider;
+            this.name = name;
+            this.version = version32;
+            this.options = options;
+          }
+          startSpan(name, options, context) {
+            return this._getTracer().startSpan(name, options, context);
+          }
+          startActiveSpan(_name, _options, _context, _fn) {
+            const tracer2 = this._getTracer();
+            return Reflect.apply(tracer2.startActiveSpan, tracer2, arguments);
+          }
+          /**
+           * Try to get a tracer from the proxy tracer provider.
+           * If the proxy tracer provider has no delegate, return a noop tracer.
+           */
+          _getTracer() {
+            if (this._delegate) {
+              return this._delegate;
+            }
+            const tracer2 = this._provider.getDelegateTracer(this.name, this.version, this.options);
+            if (!tracer2) {
+              return NOOP_TRACER;
+            }
+            this._delegate = tracer2;
+            return this._delegate;
+          }
+        };
+        exports3.ProxyTracer = ProxyTracer;
+      }
+    });
+    var require_NoopTracerProvider = __commonJS2({
+      "../../node_modules/@opentelemetry/api/build/src/trace/NoopTracerProvider.js"(exports3) {
+        "use strict";
+        Object.defineProperty(exports3, "__esModule", { value: true });
+        exports3.NoopTracerProvider = void 0;
+        var NoopTracer_1 = require_NoopTracer();
+        var NoopTracerProvider = class {
+          getTracer(_name, _version, _options) {
+            return new NoopTracer_1.NoopTracer();
+          }
+        };
+        exports3.NoopTracerProvider = NoopTracerProvider;
+      }
+    });
+    var require_ProxyTracerProvider = __commonJS2({
+      "../../node_modules/@opentelemetry/api/build/src/trace/ProxyTracerProvider.js"(exports3) {
+        "use strict";
+        Object.defineProperty(exports3, "__esModule", { value: true });
+        exports3.ProxyTracerProvider = void 0;
+        var ProxyTracer_1 = require_ProxyTracer();
+        var NoopTracerProvider_1 = require_NoopTracerProvider();
+        var NOOP_TRACER_PROVIDER = new NoopTracerProvider_1.NoopTracerProvider();
+        var ProxyTracerProvider = class {
+          /**
+           * Get a {@link ProxyTracer}
+           */
+          getTracer(name, version32, options) {
+            var _a;
+            return (_a = this.getDelegateTracer(name, version32, options)) !== null && _a !== void 0 ? _a : new ProxyTracer_1.ProxyTracer(this, name, version32, options);
+          }
+          getDelegate() {
+            var _a;
+            return (_a = this._delegate) !== null && _a !== void 0 ? _a : NOOP_TRACER_PROVIDER;
+          }
+          /**
+           * Set the delegate tracer provider
+           */
+          setDelegate(delegate) {
+            this._delegate = delegate;
+          }
+          getDelegateTracer(name, version32, options) {
+            var _a;
+            return (_a = this._delegate) === null || _a === void 0 ? void 0 : _a.getTracer(name, version32, options);
+          }
+        };
+        exports3.ProxyTracerProvider = ProxyTracerProvider;
+      }
+    });
+    var require_SamplingResult = __commonJS2({
+      "../../node_modules/@opentelemetry/api/build/src/trace/SamplingResult.js"(exports3) {
+        "use strict";
+        Object.defineProperty(exports3, "__esModule", { value: true });
+        exports3.SamplingDecision = void 0;
+        var SamplingDecision;
+        (function(SamplingDecision2) {
+          SamplingDecision2[SamplingDecision2["NOT_RECORD"] = 0] = "NOT_RECORD";
+          SamplingDecision2[SamplingDecision2["RECORD"] = 1] = "RECORD";
+          SamplingDecision2[SamplingDecision2["RECORD_AND_SAMPLED"] = 2] = "RECORD_AND_SAMPLED";
+        })(SamplingDecision = exports3.SamplingDecision || (exports3.SamplingDecision = {}));
+      }
+    });
+    var require_span_kind = __commonJS2({
+      "../../node_modules/@opentelemetry/api/build/src/trace/span_kind.js"(exports3) {
+        "use strict";
+        Object.defineProperty(exports3, "__esModule", { value: true });
+        exports3.SpanKind = void 0;
+        var SpanKind;
+        (function(SpanKind2) {
+          SpanKind2[SpanKind2["INTERNAL"] = 0] = "INTERNAL";
+          SpanKind2[SpanKind2["SERVER"] = 1] = "SERVER";
+          SpanKind2[SpanKind2["CLIENT"] = 2] = "CLIENT";
+          SpanKind2[SpanKind2["PRODUCER"] = 3] = "PRODUCER";
+          SpanKind2[SpanKind2["CONSUMER"] = 4] = "CONSUMER";
+        })(SpanKind = exports3.SpanKind || (exports3.SpanKind = {}));
+      }
+    });
+    var require_status = __commonJS2({
+      "../../node_modules/@opentelemetry/api/build/src/trace/status.js"(exports3) {
+        "use strict";
+        Object.defineProperty(exports3, "__esModule", { value: true });
+        exports3.SpanStatusCode = void 0;
+        var SpanStatusCode;
+        (function(SpanStatusCode2) {
+          SpanStatusCode2[SpanStatusCode2["UNSET"] = 0] = "UNSET";
+          SpanStatusCode2[SpanStatusCode2["OK"] = 1] = "OK";
+          SpanStatusCode2[SpanStatusCode2["ERROR"] = 2] = "ERROR";
+        })(SpanStatusCode = exports3.SpanStatusCode || (exports3.SpanStatusCode = {}));
+      }
+    });
+    var require_tracestate_validators = __commonJS2({
+      "../../node_modules/@opentelemetry/api/build/src/trace/internal/tracestate-validators.js"(exports3) {
+        "use strict";
+        Object.defineProperty(exports3, "__esModule", { value: true });
+        exports3.validateValue = exports3.validateKey = void 0;
+        var VALID_KEY_CHAR_RANGE = "[_0-9a-z-*/]";
+        var VALID_KEY = `[a-z]${VALID_KEY_CHAR_RANGE}{0,255}`;
+        var VALID_VENDOR_KEY = `[a-z0-9]${VALID_KEY_CHAR_RANGE}{0,240}@[a-z]${VALID_KEY_CHAR_RANGE}{0,13}`;
+        var VALID_KEY_REGEX = new RegExp(`^(?:${VALID_KEY}|${VALID_VENDOR_KEY})$`);
+        var VALID_VALUE_BASE_REGEX = /^[ -~]{0,255}[!-~]$/;
+        var INVALID_VALUE_COMMA_EQUAL_REGEX = /,|=/;
+        function validateKey(key) {
+          return VALID_KEY_REGEX.test(key);
+        }
+        exports3.validateKey = validateKey;
+        function validateValue(value) {
+          return VALID_VALUE_BASE_REGEX.test(value) && !INVALID_VALUE_COMMA_EQUAL_REGEX.test(value);
+        }
+        exports3.validateValue = validateValue;
+      }
+    });
+    var require_tracestate_impl = __commonJS2({
+      "../../node_modules/@opentelemetry/api/build/src/trace/internal/tracestate-impl.js"(exports3) {
+        "use strict";
+        Object.defineProperty(exports3, "__esModule", { value: true });
+        exports3.TraceStateImpl = void 0;
+        var tracestate_validators_1 = require_tracestate_validators();
+        var MAX_TRACE_STATE_ITEMS = 32;
+        var MAX_TRACE_STATE_LEN = 512;
+        var LIST_MEMBERS_SEPARATOR = ",";
+        var LIST_MEMBER_KEY_VALUE_SPLITTER = "=";
+        var TraceStateImpl = class {
+          constructor(rawTraceState) {
+            this._internalState = /* @__PURE__ */ new Map();
+            if (rawTraceState)
+              this._parse(rawTraceState);
+          }
+          set(key, value) {
+            const traceState = this._clone();
+            if (traceState._internalState.has(key)) {
+              traceState._internalState.delete(key);
+            }
+            traceState._internalState.set(key, value);
+            return traceState;
+          }
+          unset(key) {
+            const traceState = this._clone();
+            traceState._internalState.delete(key);
+            return traceState;
+          }
+          get(key) {
+            return this._internalState.get(key);
+          }
+          serialize() {
+            return this._keys().reduce((agg, key) => {
+              agg.push(key + LIST_MEMBER_KEY_VALUE_SPLITTER + this.get(key));
+              return agg;
+            }, []).join(LIST_MEMBERS_SEPARATOR);
+          }
+          _parse(rawTraceState) {
+            if (rawTraceState.length > MAX_TRACE_STATE_LEN)
+              return;
+            this._internalState = rawTraceState.split(LIST_MEMBERS_SEPARATOR).reverse().reduce((agg, part) => {
+              const listMember = part.trim();
+              const i = listMember.indexOf(LIST_MEMBER_KEY_VALUE_SPLITTER);
+              if (i !== -1) {
+                const key = listMember.slice(0, i);
+                const value = listMember.slice(i + 1, part.length);
+                if ((0, tracestate_validators_1.validateKey)(key) && (0, tracestate_validators_1.validateValue)(value)) {
+                  agg.set(key, value);
+                } else {
+                }
+              }
+              return agg;
+            }, /* @__PURE__ */ new Map());
+            if (this._internalState.size > MAX_TRACE_STATE_ITEMS) {
+              this._internalState = new Map(Array.from(this._internalState.entries()).reverse().slice(0, MAX_TRACE_STATE_ITEMS));
+            }
+          }
+          _keys() {
+            return Array.from(this._internalState.keys()).reverse();
+          }
+          _clone() {
+            const traceState = new TraceStateImpl();
+            traceState._internalState = new Map(this._internalState);
+            return traceState;
+          }
+        };
+        exports3.TraceStateImpl = TraceStateImpl;
+      }
+    });
+    var require_utils52 = __commonJS2({
+      "../../node_modules/@opentelemetry/api/build/src/trace/internal/utils.js"(exports3) {
+        "use strict";
+        Object.defineProperty(exports3, "__esModule", { value: true });
+        exports3.createTraceState = void 0;
+        var tracestate_impl_1 = require_tracestate_impl();
+        function createTraceState(rawTraceState) {
+          return new tracestate_impl_1.TraceStateImpl(rawTraceState);
+        }
+        exports3.createTraceState = createTraceState;
+      }
+    });
+    var require_context_api = __commonJS2({
+      "../../node_modules/@opentelemetry/api/build/src/context-api.js"(exports3) {
+        "use strict";
+        Object.defineProperty(exports3, "__esModule", { value: true });
+        exports3.context = void 0;
+        var context_1 = require_context22();
+        exports3.context = context_1.ContextAPI.getInstance();
+      }
+    });
+    var require_diag_api = __commonJS2({
+      "../../node_modules/@opentelemetry/api/build/src/diag-api.js"(exports3) {
+        "use strict";
+        Object.defineProperty(exports3, "__esModule", { value: true });
+        exports3.diag = void 0;
+        var diag_1 = require_diag();
+        exports3.diag = diag_1.DiagAPI.instance();
+      }
+    });
+    var require_NoopMeterProvider = __commonJS2({
+      "../../node_modules/@opentelemetry/api/build/src/metrics/NoopMeterProvider.js"(exports3) {
+        "use strict";
+        Object.defineProperty(exports3, "__esModule", { value: true });
+        exports3.NOOP_METER_PROVIDER = exports3.NoopMeterProvider = void 0;
+        var NoopMeter_1 = require_NoopMeter();
+        var NoopMeterProvider = class {
+          getMeter(_name, _version, _options) {
+            return NoopMeter_1.NOOP_METER;
+          }
+        };
+        exports3.NoopMeterProvider = NoopMeterProvider;
+        exports3.NOOP_METER_PROVIDER = new NoopMeterProvider();
+      }
+    });
+    var require_metrics = __commonJS2({
+      "../../node_modules/@opentelemetry/api/build/src/api/metrics.js"(exports3) {
+        "use strict";
+        Object.defineProperty(exports3, "__esModule", { value: true });
+        exports3.MetricsAPI = void 0;
+        var NoopMeterProvider_1 = require_NoopMeterProvider();
+        var global_utils_1 = require_global_utils();
+        var diag_1 = require_diag();
+        var API_NAME = "metrics";
+        var MetricsAPI = class {
+          /** Empty private constructor prevents end users from constructing a new instance of the API */
+          constructor() {
+          }
+          /** Get the singleton instance of the Metrics API */
+          static getInstance() {
+            if (!this._instance) {
+              this._instance = new MetricsAPI();
+            }
+            return this._instance;
+          }
+          /**
+           * Set the current global meter provider.
+           * Returns true if the meter provider was successfully registered, else false.
+           */
+          setGlobalMeterProvider(provider) {
+            return (0, global_utils_1.registerGlobal)(API_NAME, provider, diag_1.DiagAPI.instance());
+          }
+          /**
+           * Returns the global meter provider.
+           */
+          getMeterProvider() {
+            return (0, global_utils_1.getGlobal)(API_NAME) || NoopMeterProvider_1.NOOP_METER_PROVIDER;
+          }
+          /**
+           * Returns a meter from the global meter provider.
+           */
+          getMeter(name, version32, options) {
+            return this.getMeterProvider().getMeter(name, version32, options);
+          }
+          /** Remove the global meter provider */
+          disable() {
+            (0, global_utils_1.unregisterGlobal)(API_NAME, diag_1.DiagAPI.instance());
+          }
+        };
+        exports3.MetricsAPI = MetricsAPI;
+      }
+    });
+    var require_metrics_api = __commonJS2({
+      "../../node_modules/@opentelemetry/api/build/src/metrics-api.js"(exports3) {
+        "use strict";
+        Object.defineProperty(exports3, "__esModule", { value: true });
+        exports3.metrics = void 0;
+        var metrics_1 = require_metrics();
+        exports3.metrics = metrics_1.MetricsAPI.getInstance();
+      }
+    });
+    var require_NoopTextMapPropagator = __commonJS2({
+      "../../node_modules/@opentelemetry/api/build/src/propagation/NoopTextMapPropagator.js"(exports3) {
+        "use strict";
+        Object.defineProperty(exports3, "__esModule", { value: true });
+        exports3.NoopTextMapPropagator = void 0;
+        var NoopTextMapPropagator = class {
+          /** Noop inject function does nothing */
+          inject(_context, _carrier) {
+          }
+          /** Noop extract function does nothing and returns the input context */
+          extract(context, _carrier) {
+            return context;
+          }
+          fields() {
+            return [];
+          }
+        };
+        exports3.NoopTextMapPropagator = NoopTextMapPropagator;
+      }
+    });
+    var require_context_helpers = __commonJS2({
+      "../../node_modules/@opentelemetry/api/build/src/baggage/context-helpers.js"(exports3) {
+        "use strict";
+        Object.defineProperty(exports3, "__esModule", { value: true });
+        exports3.deleteBaggage = exports3.setBaggage = exports3.getActiveBaggage = exports3.getBaggage = void 0;
+        var context_1 = require_context22();
+        var context_2 = require_context2();
+        var BAGGAGE_KEY = (0, context_2.createContextKey)("OpenTelemetry Baggage Key");
+        function getBaggage(context) {
+          return context.getValue(BAGGAGE_KEY) || void 0;
+        }
+        exports3.getBaggage = getBaggage;
+        function getActiveBaggage() {
+          return getBaggage(context_1.ContextAPI.getInstance().active());
+        }
+        exports3.getActiveBaggage = getActiveBaggage;
+        function setBaggage(context, baggage) {
+          return context.setValue(BAGGAGE_KEY, baggage);
+        }
+        exports3.setBaggage = setBaggage;
+        function deleteBaggage(context) {
+          return context.deleteValue(BAGGAGE_KEY);
+        }
+        exports3.deleteBaggage = deleteBaggage;
+      }
+    });
+    var require_propagation = __commonJS2({
+      "../../node_modules/@opentelemetry/api/build/src/api/propagation.js"(exports3) {
+        "use strict";
+        Object.defineProperty(exports3, "__esModule", { value: true });
+        exports3.PropagationAPI = void 0;
+        var global_utils_1 = require_global_utils();
+        var NoopTextMapPropagator_1 = require_NoopTextMapPropagator();
+        var TextMapPropagator_1 = require_TextMapPropagator();
+        var context_helpers_1 = require_context_helpers();
+        var utils_1 = require_utils42();
+        var diag_1 = require_diag();
+        var API_NAME = "propagation";
+        var NOOP_TEXT_MAP_PROPAGATOR = new NoopTextMapPropagator_1.NoopTextMapPropagator();
+        var PropagationAPI = class {
+          /** Empty private constructor prevents end users from constructing a new instance of the API */
+          constructor() {
+            this.createBaggage = utils_1.createBaggage;
+            this.getBaggage = context_helpers_1.getBaggage;
+            this.getActiveBaggage = context_helpers_1.getActiveBaggage;
+            this.setBaggage = context_helpers_1.setBaggage;
+            this.deleteBaggage = context_helpers_1.deleteBaggage;
+          }
+          /** Get the singleton instance of the Propagator API */
+          static getInstance() {
+            if (!this._instance) {
+              this._instance = new PropagationAPI();
+            }
+            return this._instance;
+          }
+          /**
+           * Set the current propagator.
+           *
+           * @returns true if the propagator was successfully registered, else false
+           */
+          setGlobalPropagator(propagator) {
+            return (0, global_utils_1.registerGlobal)(API_NAME, propagator, diag_1.DiagAPI.instance());
+          }
+          /**
+           * Inject context into a carrier to be propagated inter-process
+           *
+           * @param context Context carrying tracing data to inject
+           * @param carrier carrier to inject context into
+           * @param setter Function used to set values on the carrier
+           */
+          inject(context, carrier, setter = TextMapPropagator_1.defaultTextMapSetter) {
+            return this._getGlobalPropagator().inject(context, carrier, setter);
+          }
+          /**
+           * Extract context from a carrier
+           *
+           * @param context Context which the newly created context will inherit from
+           * @param carrier Carrier to extract context from
+           * @param getter Function used to extract keys from a carrier
+           */
+          extract(context, carrier, getter = TextMapPropagator_1.defaultTextMapGetter) {
+            return this._getGlobalPropagator().extract(context, carrier, getter);
+          }
+          /**
+           * Return a list of all fields which may be used by the propagator.
+           */
+          fields() {
+            return this._getGlobalPropagator().fields();
+          }
+          /** Remove the global propagator */
+          disable() {
+            (0, global_utils_1.unregisterGlobal)(API_NAME, diag_1.DiagAPI.instance());
+          }
+          _getGlobalPropagator() {
+            return (0, global_utils_1.getGlobal)(API_NAME) || NOOP_TEXT_MAP_PROPAGATOR;
+          }
+        };
+        exports3.PropagationAPI = PropagationAPI;
+      }
+    });
+    var require_propagation_api = __commonJS2({
+      "../../node_modules/@opentelemetry/api/build/src/propagation-api.js"(exports3) {
+        "use strict";
+        Object.defineProperty(exports3, "__esModule", { value: true });
+        exports3.propagation = void 0;
+        var propagation_1 = require_propagation();
+        exports3.propagation = propagation_1.PropagationAPI.getInstance();
+      }
+    });
+    var require_trace = __commonJS2({
+      "../../node_modules/@opentelemetry/api/build/src/api/trace.js"(exports3) {
+        "use strict";
+        Object.defineProperty(exports3, "__esModule", { value: true });
+        exports3.TraceAPI = void 0;
+        var global_utils_1 = require_global_utils();
+        var ProxyTracerProvider_1 = require_ProxyTracerProvider();
+        var spancontext_utils_1 = require_spancontext_utils();
+        var context_utils_1 = require_context_utils();
+        var diag_1 = require_diag();
+        var API_NAME = "trace";
+        var TraceAPI = class {
+          /** Empty private constructor prevents end users from constructing a new instance of the API */
+          constructor() {
+            this._proxyTracerProvider = new ProxyTracerProvider_1.ProxyTracerProvider();
+            this.wrapSpanContext = spancontext_utils_1.wrapSpanContext;
+            this.isSpanContextValid = spancontext_utils_1.isSpanContextValid;
+            this.deleteSpan = context_utils_1.deleteSpan;
+            this.getSpan = context_utils_1.getSpan;
+            this.getActiveSpan = context_utils_1.getActiveSpan;
+            this.getSpanContext = context_utils_1.getSpanContext;
+            this.setSpan = context_utils_1.setSpan;
+            this.setSpanContext = context_utils_1.setSpanContext;
+          }
+          /** Get the singleton instance of the Trace API */
+          static getInstance() {
+            if (!this._instance) {
+              this._instance = new TraceAPI();
+            }
+            return this._instance;
+          }
+          /**
+           * Set the current global tracer.
+           *
+           * @returns true if the tracer provider was successfully registered, else false
+           */
+          setGlobalTracerProvider(provider) {
+            const success = (0, global_utils_1.registerGlobal)(API_NAME, this._proxyTracerProvider, diag_1.DiagAPI.instance());
+            if (success) {
+              this._proxyTracerProvider.setDelegate(provider);
+            }
+            return success;
+          }
+          /**
+           * Returns the global tracer provider.
+           */
+          getTracerProvider() {
+            return (0, global_utils_1.getGlobal)(API_NAME) || this._proxyTracerProvider;
+          }
+          /**
+           * Returns a tracer from the global tracer provider.
+           */
+          getTracer(name, version32) {
+            return this.getTracerProvider().getTracer(name, version32);
+          }
+          /** Remove the global tracer provider */
+          disable() {
+            (0, global_utils_1.unregisterGlobal)(API_NAME, diag_1.DiagAPI.instance());
+            this._proxyTracerProvider = new ProxyTracerProvider_1.ProxyTracerProvider();
+          }
+        };
+        exports3.TraceAPI = TraceAPI;
+      }
+    });
+    var require_trace_api = __commonJS2({
+      "../../node_modules/@opentelemetry/api/build/src/trace-api.js"(exports3) {
+        "use strict";
+        Object.defineProperty(exports3, "__esModule", { value: true });
+        exports3.trace = void 0;
+        var trace_1 = require_trace();
+        exports3.trace = trace_1.TraceAPI.getInstance();
+      }
+    });
+    var require_src2 = __commonJS2({
+      "../../node_modules/@opentelemetry/api/build/src/index.js"(exports3) {
+        "use strict";
+        Object.defineProperty(exports3, "__esModule", { value: true });
+        exports3.trace = exports3.propagation = exports3.metrics = exports3.diag = exports3.context = exports3.INVALID_SPAN_CONTEXT = exports3.INVALID_TRACEID = exports3.INVALID_SPANID = exports3.isValidSpanId = exports3.isValidTraceId = exports3.isSpanContextValid = exports3.createTraceState = exports3.TraceFlags = exports3.SpanStatusCode = exports3.SpanKind = exports3.SamplingDecision = exports3.ProxyTracerProvider = exports3.ProxyTracer = exports3.defaultTextMapSetter = exports3.defaultTextMapGetter = exports3.ValueType = exports3.createNoopMeter = exports3.DiagLogLevel = exports3.DiagConsoleLogger = exports3.ROOT_CONTEXT = exports3.createContextKey = exports3.baggageEntryMetadataFromString = void 0;
+        var utils_1 = require_utils42();
+        Object.defineProperty(exports3, "baggageEntryMetadataFromString", { enumerable: true, get: function() {
+          return utils_1.baggageEntryMetadataFromString;
+        } });
+        var context_1 = require_context2();
+        Object.defineProperty(exports3, "createContextKey", { enumerable: true, get: function() {
+          return context_1.createContextKey;
+        } });
+        Object.defineProperty(exports3, "ROOT_CONTEXT", { enumerable: true, get: function() {
+          return context_1.ROOT_CONTEXT;
+        } });
+        var consoleLogger_1 = require_consoleLogger();
+        Object.defineProperty(exports3, "DiagConsoleLogger", { enumerable: true, get: function() {
+          return consoleLogger_1.DiagConsoleLogger;
+        } });
+        var types_1 = require_types();
+        Object.defineProperty(exports3, "DiagLogLevel", { enumerable: true, get: function() {
+          return types_1.DiagLogLevel;
+        } });
+        var NoopMeter_1 = require_NoopMeter();
+        Object.defineProperty(exports3, "createNoopMeter", { enumerable: true, get: function() {
+          return NoopMeter_1.createNoopMeter;
+        } });
+        var Metric_1 = require_Metric();
+        Object.defineProperty(exports3, "ValueType", { enumerable: true, get: function() {
+          return Metric_1.ValueType;
+        } });
+        var TextMapPropagator_1 = require_TextMapPropagator();
+        Object.defineProperty(exports3, "defaultTextMapGetter", { enumerable: true, get: function() {
+          return TextMapPropagator_1.defaultTextMapGetter;
+        } });
+        Object.defineProperty(exports3, "defaultTextMapSetter", { enumerable: true, get: function() {
+          return TextMapPropagator_1.defaultTextMapSetter;
+        } });
+        var ProxyTracer_1 = require_ProxyTracer();
+        Object.defineProperty(exports3, "ProxyTracer", { enumerable: true, get: function() {
+          return ProxyTracer_1.ProxyTracer;
+        } });
+        var ProxyTracerProvider_1 = require_ProxyTracerProvider();
+        Object.defineProperty(exports3, "ProxyTracerProvider", { enumerable: true, get: function() {
+          return ProxyTracerProvider_1.ProxyTracerProvider;
+        } });
+        var SamplingResult_1 = require_SamplingResult();
+        Object.defineProperty(exports3, "SamplingDecision", { enumerable: true, get: function() {
+          return SamplingResult_1.SamplingDecision;
+        } });
+        var span_kind_1 = require_span_kind();
+        Object.defineProperty(exports3, "SpanKind", { enumerable: true, get: function() {
+          return span_kind_1.SpanKind;
+        } });
+        var status_1 = require_status();
+        Object.defineProperty(exports3, "SpanStatusCode", { enumerable: true, get: function() {
+          return status_1.SpanStatusCode;
+        } });
+        var trace_flags_1 = require_trace_flags();
+        Object.defineProperty(exports3, "TraceFlags", { enumerable: true, get: function() {
+          return trace_flags_1.TraceFlags;
+        } });
+        var utils_2 = require_utils52();
+        Object.defineProperty(exports3, "createTraceState", { enumerable: true, get: function() {
+          return utils_2.createTraceState;
+        } });
+        var spancontext_utils_1 = require_spancontext_utils();
+        Object.defineProperty(exports3, "isSpanContextValid", { enumerable: true, get: function() {
+          return spancontext_utils_1.isSpanContextValid;
+        } });
+        Object.defineProperty(exports3, "isValidTraceId", { enumerable: true, get: function() {
+          return spancontext_utils_1.isValidTraceId;
+        } });
+        Object.defineProperty(exports3, "isValidSpanId", { enumerable: true, get: function() {
+          return spancontext_utils_1.isValidSpanId;
+        } });
+        var invalid_span_constants_1 = require_invalid_span_constants();
+        Object.defineProperty(exports3, "INVALID_SPANID", { enumerable: true, get: function() {
+          return invalid_span_constants_1.INVALID_SPANID;
+        } });
+        Object.defineProperty(exports3, "INVALID_TRACEID", { enumerable: true, get: function() {
+          return invalid_span_constants_1.INVALID_TRACEID;
+        } });
+        Object.defineProperty(exports3, "INVALID_SPAN_CONTEXT", { enumerable: true, get: function() {
+          return invalid_span_constants_1.INVALID_SPAN_CONTEXT;
+        } });
+        var context_api_1 = require_context_api();
+        Object.defineProperty(exports3, "context", { enumerable: true, get: function() {
+          return context_api_1.context;
+        } });
+        var diag_api_1 = require_diag_api();
+        Object.defineProperty(exports3, "diag", { enumerable: true, get: function() {
+          return diag_api_1.diag;
+        } });
+        var metrics_api_1 = require_metrics_api();
+        Object.defineProperty(exports3, "metrics", { enumerable: true, get: function() {
+          return metrics_api_1.metrics;
+        } });
+        var propagation_api_1 = require_propagation_api();
+        Object.defineProperty(exports3, "propagation", { enumerable: true, get: function() {
+          return propagation_api_1.propagation;
+        } });
+        var trace_api_1 = require_trace_api();
+        Object.defineProperty(exports3, "trace", { enumerable: true, get: function() {
+          return trace_api_1.trace;
+        } });
+        exports3.default = {
+          context: context_api_1.context,
+          diag: diag_api_1.diag,
+          metrics: metrics_api_1.metrics,
+          propagation: propagation_api_1.propagation,
+          trace: trace_api_1.trace
+        };
+      }
+    });
     var src_exports = {};
     __export2(src_exports, {
       AbstractDynamoDbRepository: () => AbstractDynamoDbRepository,
@@ -106347,6 +107901,8 @@ ${originalIndentation}`;
         this.name = "TransactionError";
       }
     };
+    var import_api = __toESM2(require_src2());
+    var tracer = import_api.trace.getTracer("db-lib:DynamoDbManager");
     var DynamoDbManager = class {
       constructor(client, repositoryCreator) {
         this.client = client;
@@ -106374,10 +107930,27 @@ ${originalIndentation}`;
         if (this.transactionItems[transactionId] === void 0) {
           throw new TransactionError(`No items in transaction '${transactionId}' to execute`);
         }
-        return await this.client.transactWrite({
-          ClientRequestToken: transactionId,
-          TransactItems: this.transactionItems[transactionId]
-        });
+        if (!this.transactionItems[transactionId].length) {
+          return;
+        }
+        return tracer.startActiveSpan(
+          "executeTransaction",
+          {
+            attributes: {
+              "transactionItems.length": this.transactionItems[transactionId].length
+            }
+          },
+          async (span) => {
+            try {
+              return await this.client.transactWrite({
+                ClientRequestToken: transactionId,
+                TransactItems: this.transactionItems[transactionId]
+              });
+            } finally {
+              span.end();
+            }
+          }
+        );
       }
       startTransaction(transactionId) {
         if (this.transactionItems[transactionId] !== void 0) {
@@ -106609,6 +108182,7 @@ ${originalIndentation}`;
           ConditionExpression: `attribute_exists(${this.keys.pk.attributeName})`
         };
         if ((_a = transaction.id) == null ? void 0 : _a.length) {
+          delete deleteCommandInput.ConditionExpression;
           this.dbManager.addWriteTransactionItem(transaction.id, {
             Delete: deleteCommandInput
           });
@@ -119746,11 +121320,11 @@ var require_ManifestServiceForDev = __commonJS({
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.ManifestServiceForDev = void 0;
-    var path_1 = __importDefault8(require("path"));
-    var promises_1 = __importDefault8(require("fs/promises"));
-    var AbstractManifestService_1 = require_AbstractManifestService();
     var dx_common_lib_1 = require_lib5();
+    var promises_1 = __importDefault8(require("fs/promises"));
+    var path_1 = __importDefault8(require("path"));
     var getComponentName_1 = require_getComponentName();
+    var AbstractManifestService_1 = require_AbstractManifestService();
     var ManifestServiceForDev = class extends AbstractManifestService_1.AbstractManifestService {
       constructor(componentMountPoint, logger) {
         super(logger);
@@ -119765,10 +121339,11 @@ var require_ManifestServiceForDev = __commonJS({
         return this.foundManifests.map((a) => a.manifest);
       }
       async getManifestPath(namespace, componentName, version5) {
-        if (this.foundManifests.length === 0) {
+        let manifest = this.foundManifests.find((m) => m.manifest.getName() === (0, getComponentName_1.getComponentName)(namespace, componentName) && m.manifest.getVersion() === version5);
+        if (this.foundManifests.length === 0 || !manifest) {
           this.foundManifests = await this.recursivelyLookForManifests(this.componentMountPoint);
         }
-        const manifest = this.foundManifests.find((m) => m.manifest.getName() === (0, getComponentName_1.getComponentName)(namespace, componentName) && m.manifest.getVersion() === version5);
+        manifest = this.foundManifests.find((m) => m.manifest.getName() === (0, getComponentName_1.getComponentName)(namespace, componentName) && m.manifest.getVersion() === version5);
         if (manifest) {
           return path_1.default.join(manifest.directory, "manifest.json");
         }
@@ -164728,7 +166303,7 @@ archiver/index.js:
  */
 /**
  * @title @squiz/content-api
- * @version 1.80.0
+ * @version 1.82.0
  * @license ISC
  * @baseUrl /
  * @contact