@ensembleapp/client-sdk 0.0.56 → 0.0.57

package/dist/chunk-LFKJR7WX.js

@@ -0,0 +1,1013 @@
+import {
+  __commonJS,
+  __toESM
+} from "./chunk-YLJ4XMA6.js";
+
+// ../../node_modules/.pnpm/quick-format-unescaped@4.0.4/node_modules/quick-format-unescaped/index.js
+var require_quick_format_unescaped = __commonJS({
+  "../../node_modules/.pnpm/quick-format-unescaped@4.0.4/node_modules/quick-format-unescaped/index.js"(exports, module) {
+    "use strict";
+    function tryStringify(o) {
+      try {
+        return JSON.stringify(o);
+      } catch (e) {
+        return '"[Circular]"';
+      }
+    }
+    module.exports = format;
+    function format(f, args, opts) {
+      var ss = opts && opts.stringify || tryStringify;
+      var offset = 1;
+      if (typeof f === "object" && f !== null) {
+        var len = args.length + offset;
+        if (len === 1) return f;
+        var objects = new Array(len);
+        objects[0] = ss(f);
+        for (var index = 1; index < len; index++) {
+          objects[index] = ss(args[index]);
+        }
+        return objects.join(" ");
+      }
+      if (typeof f !== "string") {
+        return f;
+      }
+      var argLen = args.length;
+      if (argLen === 0) return f;
+      var str = "";
+      var a = 1 - offset;
+      var lastPos = -1;
+      var flen = f && f.length || 0;
+      for (var i = 0; i < flen; ) {
+        if (f.charCodeAt(i) === 37 && i + 1 < flen) {
+          lastPos = lastPos > -1 ? lastPos : 0;
+          switch (f.charCodeAt(i + 1)) {
+            case 100:
+            // 'd'
+            case 102:
+              if (a >= argLen)
+                break;
+              if (args[a] == null) break;
+              if (lastPos < i)
+                str += f.slice(lastPos, i);
+              str += Number(args[a]);
+              lastPos = i + 2;
+              i++;
+              break;
+            case 105:
+              if (a >= argLen)
+                break;
+              if (args[a] == null) break;
+              if (lastPos < i)
+                str += f.slice(lastPos, i);
+              str += Math.floor(Number(args[a]));
+              lastPos = i + 2;
+              i++;
+              break;
+            case 79:
+            // 'O'
+            case 111:
+            // 'o'
+            case 106:
+              if (a >= argLen)
+                break;
+              if (args[a] === void 0) break;
+              if (lastPos < i)
+                str += f.slice(lastPos, i);
+              var type = typeof args[a];
+              if (type === "string") {
+                str += "'" + args[a] + "'";
+                lastPos = i + 2;
+                i++;
+                break;
+              }
+              if (type === "function") {
+                str += args[a].name || "<anonymous>";
+                lastPos = i + 2;
+                i++;
+                break;
+              }
+              str += ss(args[a]);
+              lastPos = i + 2;
+              i++;
+              break;
+            case 115:
+              if (a >= argLen)
+                break;
+              if (lastPos < i)
+                str += f.slice(lastPos, i);
+              str += String(args[a]);
+              lastPos = i + 2;
+              i++;
+              break;
+            case 37:
+              if (lastPos < i)
+                str += f.slice(lastPos, i);
+              str += "%";
+              lastPos = i + 2;
+              i++;
+              a--;
+              break;
+          }
+          ++a;
+        }
+        ++i;
+      }
+      if (lastPos === -1)
+        return f;
+      else if (lastPos < flen) {
+        str += f.slice(lastPos);
+      }
+      return str;
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/pino@10.3.1/node_modules/pino/browser.js
+var require_browser = __commonJS({
+  "../../node_modules/.pnpm/pino@10.3.1/node_modules/pino/browser.js"(exports, module) {
+    "use strict";
+    var format = require_quick_format_unescaped();
+    module.exports = pino2;
+    var _console = pfGlobalThisOrFallback().console || {};
+    var stdSerializers = {
+      mapHttpRequest: mock,
+      mapHttpResponse: mock,
+      wrapRequestSerializer: passthrough,
+      wrapResponseSerializer: passthrough,
+      wrapErrorSerializer: passthrough,
+      req: mock,
+      res: mock,
+      err: asErrValue,
+      errWithCause: asErrValue
+    };
+    function levelToValue(level, logger) {
+      return level === "silent" ? Infinity : logger.levels.values[level];
+    }
+    var baseLogFunctionSymbol = /* @__PURE__ */ Symbol("pino.logFuncs");
+    var hierarchySymbol = /* @__PURE__ */ Symbol("pino.hierarchy");
+    var logFallbackMap = {
+      error: "log",
+      fatal: "error",
+      warn: "error",
+      info: "log",
+      debug: "log",
+      trace: "log"
+    };
+    function appendChildLogger(parentLogger, childLogger) {
+      const newEntry = {
+        logger: childLogger,
+        parent: parentLogger[hierarchySymbol]
+      };
+      childLogger[hierarchySymbol] = newEntry;
+    }
+    function setupBaseLogFunctions(logger, levels, proto) {
+      const logFunctions = {};
+      levels.forEach((level) => {
+        logFunctions[level] = proto[level] ? proto[level] : _console[level] || _console[logFallbackMap[level] || "log"] || noop;
+      });
+      logger[baseLogFunctionSymbol] = logFunctions;
+    }
+    function shouldSerialize(serialize, serializers) {
+      if (Array.isArray(serialize)) {
+        const hasToFilter = serialize.filter(function(k) {
+          return k !== "!stdSerializers.err";
+        });
+        return hasToFilter;
+      } else if (serialize === true) {
+        return Object.keys(serializers);
+      }
+      return false;
+    }
+    function pino2(opts) {
+      opts = opts || {};
+      opts.browser = opts.browser || {};
+      const transmit2 = opts.browser.transmit;
+      if (transmit2 && typeof transmit2.send !== "function") {
+        throw Error("pino: transmit option must have a send function");
+      }
+      const proto = opts.browser.write || _console;
+      if (opts.browser.write) opts.browser.asObject = true;
+      const serializers = opts.serializers || {};
+      const serialize = shouldSerialize(opts.browser.serialize, serializers);
+      let stdErrSerialize = opts.browser.serialize;
+      if (Array.isArray(opts.browser.serialize) && opts.browser.serialize.indexOf("!stdSerializers.err") > -1) stdErrSerialize = false;
+      const customLevels = Object.keys(opts.customLevels || {});
+      const levels = ["error", "fatal", "warn", "info", "debug", "trace"].concat(customLevels);
+      if (typeof proto === "function") {
+        levels.forEach(function(level2) {
+          proto[level2] = proto;
+        });
+      }
+      if (opts.enabled === false || opts.browser.disabled) opts.level = "silent";
+      const level = opts.level || "info";
+      const logger = Object.create(proto);
+      if (!logger.log) logger.log = noop;
+      setupBaseLogFunctions(logger, levels, proto);
+      appendChildLogger({}, logger);
+      Object.defineProperty(logger, "levelVal", {
+        get: getLevelVal
+      });
+      Object.defineProperty(logger, "level", {
+        get: getLevel,
+        set: setLevel
+      });
+      const setOpts = {
+        transmit: transmit2,
+        serialize,
+        asObject: opts.browser.asObject,
+        asObjectBindingsOnly: opts.browser.asObjectBindingsOnly,
+        formatters: opts.browser.formatters,
+        reportCaller: opts.browser.reportCaller,
+        levels,
+        timestamp: getTimeFunction(opts),
+        messageKey: opts.messageKey || "msg",
+        onChild: opts.onChild || noop
+      };
+      logger.levels = getLevels(opts);
+      logger.level = level;
+      logger.isLevelEnabled = function(level2) {
+        if (!this.levels.values[level2]) {
+          return false;
+        }
+        return this.levels.values[level2] >= this.levels.values[this.level];
+      };
+      logger.setMaxListeners = logger.getMaxListeners = logger.emit = logger.addListener = logger.on = logger.prependListener = logger.once = logger.prependOnceListener = logger.removeListener = logger.removeAllListeners = logger.listeners = logger.listenerCount = logger.eventNames = logger.write = logger.flush = noop;
+      logger.serializers = serializers;
+      logger._serialize = serialize;
+      logger._stdErrSerialize = stdErrSerialize;
+      logger.child = function(...args) {
+        return child.call(this, setOpts, ...args);
+      };
+      if (transmit2) logger._logEvent = createLogEventShape();
+      function getLevelVal() {
+        return levelToValue(this.level, this);
+      }
+      function getLevel() {
+        return this._level;
+      }
+      function setLevel(level2) {
+        if (level2 !== "silent" && !this.levels.values[level2]) {
+          throw Error("unknown level " + level2);
+        }
+        this._level = level2;
+        set(this, setOpts, logger, "error");
+        set(this, setOpts, logger, "fatal");
+        set(this, setOpts, logger, "warn");
+        set(this, setOpts, logger, "info");
+        set(this, setOpts, logger, "debug");
+        set(this, setOpts, logger, "trace");
+        customLevels.forEach((level3) => {
+          set(this, setOpts, logger, level3);
+        });
+      }
+      function child(setOpts2, bindings, childOptions) {
+        if (!bindings) {
+          throw new Error("missing bindings for child Pino");
+        }
+        childOptions = childOptions || {};
+        if (serialize && bindings.serializers) {
+          childOptions.serializers = bindings.serializers;
+        }
+        const childOptionsSerializers = childOptions.serializers;
+        if (serialize && childOptionsSerializers) {
+          var childSerializers = Object.assign({}, serializers, childOptionsSerializers);
+          var childSerialize = opts.browser.serialize === true ? Object.keys(childSerializers) : serialize;
+          delete bindings.serializers;
+          applySerializers([bindings], childSerialize, childSerializers, this._stdErrSerialize);
+        }
+        function Child(parent) {
+          this._childLevel = (parent._childLevel | 0) + 1;
+          this.bindings = bindings;
+          if (childSerializers) {
+            this.serializers = childSerializers;
+            this._serialize = childSerialize;
+          }
+          if (transmit2) {
+            this._logEvent = createLogEventShape(
+              [].concat(parent._logEvent.bindings, bindings)
+            );
+          }
+        }
+        Child.prototype = this;
+        const newLogger = new Child(this);
+        appendChildLogger(this, newLogger);
+        newLogger.child = function(...args) {
+          return child.call(this, setOpts2, ...args);
+        };
+        newLogger.level = childOptions.level || this.level;
+        setOpts2.onChild(newLogger);
+        return newLogger;
+      }
+      return logger;
+    }
+    function getLevels(opts) {
+      const customLevels = opts.customLevels || {};
+      const values = Object.assign({}, pino2.levels.values, customLevels);
+      const labels = Object.assign({}, pino2.levels.labels, invertObject(customLevels));
+      return {
+        values,
+        labels
+      };
+    }
+    function invertObject(obj) {
+      const inverted = {};
+      Object.keys(obj).forEach(function(key) {
+        inverted[obj[key]] = key;
+      });
+      return inverted;
+    }
+    pino2.levels = {
+      values: {
+        fatal: 60,
+        error: 50,
+        warn: 40,
+        info: 30,
+        debug: 20,
+        trace: 10
+      },
+      labels: {
+        10: "trace",
+        20: "debug",
+        30: "info",
+        40: "warn",
+        50: "error",
+        60: "fatal"
+      }
+    };
+    pino2.stdSerializers = stdSerializers;
+    pino2.stdTimeFunctions = Object.assign({}, { nullTime, epochTime, unixTime, isoTime });
+    function getBindingChain(logger) {
+      const bindings = [];
+      if (logger.bindings) {
+        bindings.push(logger.bindings);
+      }
+      let hierarchy = logger[hierarchySymbol];
+      while (hierarchy.parent) {
+        hierarchy = hierarchy.parent;
+        if (hierarchy.logger.bindings) {
+          bindings.push(hierarchy.logger.bindings);
+        }
+      }
+      return bindings.reverse();
+    }
+    function set(self2, opts, rootLogger, level) {
+      Object.defineProperty(self2, level, {
+        value: levelToValue(self2.level, rootLogger) > levelToValue(level, rootLogger) ? noop : rootLogger[baseLogFunctionSymbol][level],
+        writable: true,
+        enumerable: true,
+        configurable: true
+      });
+      if (self2[level] === noop) {
+        if (!opts.transmit) return;
+        const transmitLevel = opts.transmit.level || self2.level;
+        const transmitValue = levelToValue(transmitLevel, rootLogger);
+        const methodValue = levelToValue(level, rootLogger);
+        if (methodValue < transmitValue) return;
+      }
+      self2[level] = createWrap(self2, opts, rootLogger, level);
+      const bindings = getBindingChain(self2);
+      if (bindings.length === 0) {
+        return;
+      }
+      self2[level] = prependBindingsInArguments(bindings, self2[level]);
+    }
+    function prependBindingsInArguments(bindings, logFunc) {
+      return function() {
+        return logFunc.apply(this, [...bindings, ...arguments]);
+      };
+    }
+    function createWrap(self2, opts, rootLogger, level) {
+      return /* @__PURE__ */ (function(write) {
+        return function LOG() {
+          const ts = opts.timestamp();
+          const args = new Array(arguments.length);
+          const proto = Object.getPrototypeOf && Object.getPrototypeOf(this) === _console ? _console : this;
+          for (var i = 0; i < args.length; i++) args[i] = arguments[i];
+          var argsIsSerialized = false;
+          if (opts.serialize) {
+            applySerializers(args, this._serialize, this.serializers, this._stdErrSerialize);
+            argsIsSerialized = true;
+          }
+          if (opts.asObject || opts.formatters) {
+            const out = asObject(this, level, args, ts, opts);
+            if (opts.reportCaller && out && out.length > 0 && out[0] && typeof out[0] === "object") {
+              try {
+                const caller = getCallerLocation();
+                if (caller) out[0].caller = caller;
+              } catch (e) {
+              }
+            }
+            write.call(proto, ...out);
+          } else {
+            if (opts.reportCaller) {
+              try {
+                const caller = getCallerLocation();
+                if (caller) args.push(caller);
+              } catch (e) {
+              }
+            }
+            write.apply(proto, args);
+          }
+          if (opts.transmit) {
+            const transmitLevel = opts.transmit.level || self2._level;
+            const transmitValue = levelToValue(transmitLevel, rootLogger);
+            const methodValue = levelToValue(level, rootLogger);
+            if (methodValue < transmitValue) return;
+            transmit(this, {
+              ts,
+              methodLevel: level,
+              methodValue,
+              transmitLevel,
+              transmitValue: rootLogger.levels.values[opts.transmit.level || self2._level],
+              send: opts.transmit.send,
+              val: levelToValue(self2._level, rootLogger)
+            }, args, argsIsSerialized);
+          }
+        };
+      })(self2[baseLogFunctionSymbol][level]);
+    }
+    function asObject(logger, level, args, ts, opts) {
+      const {
+        level: levelFormatter,
+        log: logObjectFormatter = (obj) => obj
+      } = opts.formatters || {};
+      const argsCloned = args.slice();
+      let msg = argsCloned[0];
+      const logObject = {};
+      let lvl = (logger._childLevel | 0) + 1;
+      if (lvl < 1) lvl = 1;
+      if (ts) {
+        logObject.time = ts;
+      }
+      if (levelFormatter) {
+        const formattedLevel = levelFormatter(level, logger.levels.values[level]);
+        Object.assign(logObject, formattedLevel);
+      } else {
+        logObject.level = logger.levels.values[level];
+      }
+      if (opts.asObjectBindingsOnly) {
+        if (msg !== null && typeof msg === "object") {
+          while (lvl-- && typeof argsCloned[0] === "object") {
+            Object.assign(logObject, argsCloned.shift());
+          }
+        }
+        const formattedLogObject = logObjectFormatter(logObject);
+        return [formattedLogObject, ...argsCloned];
+      } else {
+        if (msg !== null && typeof msg === "object") {
+          while (lvl-- && typeof argsCloned[0] === "object") {
+            Object.assign(logObject, argsCloned.shift());
+          }
+          msg = argsCloned.length ? format(argsCloned.shift(), argsCloned) : void 0;
+        } else if (typeof msg === "string") msg = format(argsCloned.shift(), argsCloned);
+        if (msg !== void 0) logObject[opts.messageKey] = msg;
+        const formattedLogObject = logObjectFormatter(logObject);
+        return [formattedLogObject];
+      }
+    }
+    function applySerializers(args, serialize, serializers, stdErrSerialize) {
+      for (const i in args) {
+        if (stdErrSerialize && args[i] instanceof Error) {
+          args[i] = pino2.stdSerializers.err(args[i]);
+        } else if (typeof args[i] === "object" && !Array.isArray(args[i]) && serialize) {
+          for (const k in args[i]) {
+            if (serialize.indexOf(k) > -1 && k in serializers) {
+              args[i][k] = serializers[k](args[i][k]);
+            }
+          }
+        }
+      }
+    }
+    function transmit(logger, opts, args, argsIsSerialized = false) {
+      const send = opts.send;
+      const ts = opts.ts;
+      const methodLevel = opts.methodLevel;
+      const methodValue = opts.methodValue;
+      const val = opts.val;
+      const bindings = logger._logEvent.bindings;
+      if (!argsIsSerialized) {
+        applySerializers(
+          args,
+          logger._serialize || Object.keys(logger.serializers),
+          logger.serializers,
+          logger._stdErrSerialize === void 0 ? true : logger._stdErrSerialize
+        );
+      }
+      logger._logEvent.ts = ts;
+      logger._logEvent.messages = args.filter(function(arg) {
+        return bindings.indexOf(arg) === -1;
+      });
+      logger._logEvent.level.label = methodLevel;
+      logger._logEvent.level.value = methodValue;
+      send(methodLevel, logger._logEvent, val);
+      logger._logEvent = createLogEventShape(bindings);
+    }
+    function createLogEventShape(bindings) {
+      return {
+        ts: 0,
+        messages: [],
+        bindings: bindings || [],
+        level: { label: "", value: 0 }
+      };
+    }
+    function asErrValue(err) {
+      const obj = {
+        type: err.constructor.name,
+        msg: err.message,
+        stack: err.stack
+      };
+      for (const key in err) {
+        if (obj[key] === void 0) {
+          obj[key] = err[key];
+        }
+      }
+      return obj;
+    }
+    function getTimeFunction(opts) {
+      if (typeof opts.timestamp === "function") {
+        return opts.timestamp;
+      }
+      if (opts.timestamp === false) {
+        return nullTime;
+      }
+      return epochTime;
+    }
+    function mock() {
+      return {};
+    }
+    function passthrough(a) {
+      return a;
+    }
+    function noop() {
+    }
+    function nullTime() {
+      return false;
+    }
+    function epochTime() {
+      return Date.now();
+    }
+    function unixTime() {
+      return Math.round(Date.now() / 1e3);
+    }
+    function isoTime() {
+      return new Date(Date.now()).toISOString();
+    }
+    function pfGlobalThisOrFallback() {
+      function defd(o) {
+        return typeof o !== "undefined" && o;
+      }
+      try {
+        if (typeof globalThis !== "undefined") return globalThis;
+        Object.defineProperty(Object.prototype, "globalThis", {
+          get: function() {
+            delete Object.prototype.globalThis;
+            return this.globalThis = this;
+          },
+          configurable: true
+        });
+        return globalThis;
+      } catch (e) {
+        return defd(self) || defd(window) || defd(this) || {};
+      }
+    }
+    module.exports.default = pino2;
+    module.exports.pino = pino2;
+    function getCallerLocation() {
+      const stack = new Error().stack;
+      if (!stack) return null;
+      const lines = stack.split("\n");
+      for (let i = 1; i < lines.length; i++) {
+        const l = lines[i].trim();
+        if (/(^at\s+)?(createWrap|LOG|set\s*\(|asObject|Object\.apply|Function\.apply)/.test(l)) continue;
+        if (l.indexOf("browser.js") !== -1) continue;
+        if (l.indexOf("node:internal") !== -1) continue;
+        if (l.indexOf("node_modules") !== -1) continue;
+        let m = l.match(/\((.*?):(\d+):(\d+)\)/);
+        if (!m) m = l.match(/at\s+(.*?):(\d+):(\d+)/);
+        if (m) {
+          const file = m[1];
+          const line = m[2];
+          const col = m[3];
+          return file + ":" + line + ":" + col;
+        }
+      }
+      return null;
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/pino-std-serializers@7.1.0/node_modules/pino-std-serializers/lib/err-helpers.js
+var require_err_helpers = __commonJS({
+  "../../node_modules/.pnpm/pino-std-serializers@7.1.0/node_modules/pino-std-serializers/lib/err-helpers.js"(exports, module) {
+    "use strict";
+    var isErrorLike = (err) => {
+      return err && typeof err.message === "string";
+    };
+    var getErrorCause = (err) => {
+      if (!err) return;
+      const cause = err.cause;
+      if (typeof cause === "function") {
+        const causeResult = err.cause();
+        return isErrorLike(causeResult) ? causeResult : void 0;
+      } else {
+        return isErrorLike(cause) ? cause : void 0;
+      }
+    };
+    var _stackWithCauses = (err, seen) => {
+      if (!isErrorLike(err)) return "";
+      const stack = err.stack || "";
+      if (seen.has(err)) {
+        return stack + "\ncauses have become circular...";
+      }
+      const cause = getErrorCause(err);
+      if (cause) {
+        seen.add(err);
+        return stack + "\ncaused by: " + _stackWithCauses(cause, seen);
+      } else {
+        return stack;
+      }
+    };
+    var stackWithCauses = (err) => _stackWithCauses(err, /* @__PURE__ */ new Set());
+    var _messageWithCauses = (err, seen, skip) => {
+      if (!isErrorLike(err)) return "";
+      const message = skip ? "" : err.message || "";
+      if (seen.has(err)) {
+        return message + ": ...";
+      }
+      const cause = getErrorCause(err);
+      if (cause) {
+        seen.add(err);
+        const skipIfVErrorStyleCause = typeof err.cause === "function";
+        return message + (skipIfVErrorStyleCause ? "" : ": ") + _messageWithCauses(cause, seen, skipIfVErrorStyleCause);
+      } else {
+        return message;
+      }
+    };
+    var messageWithCauses = (err) => _messageWithCauses(err, /* @__PURE__ */ new Set());
+    module.exports = {
+      isErrorLike,
+      getErrorCause,
+      stackWithCauses,
+      messageWithCauses
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/pino-std-serializers@7.1.0/node_modules/pino-std-serializers/lib/err-proto.js
+var require_err_proto = __commonJS({
+  "../../node_modules/.pnpm/pino-std-serializers@7.1.0/node_modules/pino-std-serializers/lib/err-proto.js"(exports, module) {
+    "use strict";
+    var seen = /* @__PURE__ */ Symbol("circular-ref-tag");
+    var rawSymbol = /* @__PURE__ */ Symbol("pino-raw-err-ref");
+    var pinoErrProto = Object.create({}, {
+      type: {
+        enumerable: true,
+        writable: true,
+        value: void 0
+      },
+      message: {
+        enumerable: true,
+        writable: true,
+        value: void 0
+      },
+      stack: {
+        enumerable: true,
+        writable: true,
+        value: void 0
+      },
+      aggregateErrors: {
+        enumerable: true,
+        writable: true,
+        value: void 0
+      },
+      raw: {
+        enumerable: false,
+        get: function() {
+          return this[rawSymbol];
+        },
+        set: function(val) {
+          this[rawSymbol] = val;
+        }
+      }
+    });
+    Object.defineProperty(pinoErrProto, rawSymbol, {
+      writable: true,
+      value: {}
+    });
+    module.exports = {
+      pinoErrProto,
+      pinoErrorSymbols: {
+        seen,
+        rawSymbol
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/pino-std-serializers@7.1.0/node_modules/pino-std-serializers/lib/err.js
+var require_err = __commonJS({
+  "../../node_modules/.pnpm/pino-std-serializers@7.1.0/node_modules/pino-std-serializers/lib/err.js"(exports, module) {
+    "use strict";
+    module.exports = errSerializer2;
+    var { messageWithCauses, stackWithCauses, isErrorLike } = require_err_helpers();
+    var { pinoErrProto, pinoErrorSymbols } = require_err_proto();
+    var { seen } = pinoErrorSymbols;
+    var { toString } = Object.prototype;
+    function errSerializer2(err) {
+      if (!isErrorLike(err)) {
+        return err;
+      }
+      err[seen] = void 0;
+      const _err = Object.create(pinoErrProto);
+      _err.type = toString.call(err.constructor) === "[object Function]" ? err.constructor.name : err.name;
+      _err.message = messageWithCauses(err);
+      _err.stack = stackWithCauses(err);
+      if (Array.isArray(err.errors)) {
+        _err.aggregateErrors = err.errors.map((err2) => errSerializer2(err2));
+      }
+      for (const key in err) {
+        if (_err[key] === void 0) {
+          const val = err[key];
+          if (isErrorLike(val)) {
+            if (key !== "cause" && !Object.prototype.hasOwnProperty.call(val, seen)) {
+              _err[key] = errSerializer2(val);
+            }
+          } else {
+            _err[key] = val;
+          }
+        }
+      }
+      delete err[seen];
+      _err.raw = err;
+      return _err;
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/pino-std-serializers@7.1.0/node_modules/pino-std-serializers/lib/err-with-cause.js
+var require_err_with_cause = __commonJS({
+  "../../node_modules/.pnpm/pino-std-serializers@7.1.0/node_modules/pino-std-serializers/lib/err-with-cause.js"(exports, module) {
+    "use strict";
+    module.exports = errWithCauseSerializer;
+    var { isErrorLike } = require_err_helpers();
+    var { pinoErrProto, pinoErrorSymbols } = require_err_proto();
+    var { seen } = pinoErrorSymbols;
+    var { toString } = Object.prototype;
+    function errWithCauseSerializer(err) {
+      if (!isErrorLike(err)) {
+        return err;
+      }
+      err[seen] = void 0;
+      const _err = Object.create(pinoErrProto);
+      _err.type = toString.call(err.constructor) === "[object Function]" ? err.constructor.name : err.name;
+      _err.message = err.message;
+      _err.stack = err.stack;
+      if (Array.isArray(err.errors)) {
+        _err.aggregateErrors = err.errors.map((err2) => errWithCauseSerializer(err2));
+      }
+      if (isErrorLike(err.cause) && !Object.prototype.hasOwnProperty.call(err.cause, seen)) {
+        _err.cause = errWithCauseSerializer(err.cause);
+      }
+      for (const key in err) {
+        if (_err[key] === void 0) {
+          const val = err[key];
+          if (isErrorLike(val)) {
+            if (!Object.prototype.hasOwnProperty.call(val, seen)) {
+              _err[key] = errWithCauseSerializer(val);
+            }
+          } else {
+            _err[key] = val;
+          }
+        }
+      }
+      delete err[seen];
+      _err.raw = err;
+      return _err;
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/pino-std-serializers@7.1.0/node_modules/pino-std-serializers/lib/req.js
+var require_req = __commonJS({
+  "../../node_modules/.pnpm/pino-std-serializers@7.1.0/node_modules/pino-std-serializers/lib/req.js"(exports, module) {
+    "use strict";
+    module.exports = {
+      mapHttpRequest,
+      reqSerializer
+    };
+    var rawSymbol = /* @__PURE__ */ Symbol("pino-raw-req-ref");
+    var pinoReqProto = Object.create({}, {
+      id: {
+        enumerable: true,
+        writable: true,
+        value: ""
+      },
+      method: {
+        enumerable: true,
+        writable: true,
+        value: ""
+      },
+      url: {
+        enumerable: true,
+        writable: true,
+        value: ""
+      },
+      query: {
+        enumerable: true,
+        writable: true,
+        value: ""
+      },
+      params: {
+        enumerable: true,
+        writable: true,
+        value: ""
+      },
+      headers: {
+        enumerable: true,
+        writable: true,
+        value: {}
+      },
+      remoteAddress: {
+        enumerable: true,
+        writable: true,
+        value: ""
+      },
+      remotePort: {
+        enumerable: true,
+        writable: true,
+        value: ""
+      },
+      raw: {
+        enumerable: false,
+        get: function() {
+          return this[rawSymbol];
+        },
+        set: function(val) {
+          this[rawSymbol] = val;
+        }
+      }
+    });
+    Object.defineProperty(pinoReqProto, rawSymbol, {
+      writable: true,
+      value: {}
+    });
+    function reqSerializer(req) {
+      const connection = req.info || req.socket;
+      const _req = Object.create(pinoReqProto);
+      _req.id = typeof req.id === "function" ? req.id() : req.id || (req.info ? req.info.id : void 0);
+      _req.method = req.method;
+      if (req.originalUrl) {
+        _req.url = req.originalUrl;
+      } else {
+        const path = req.path;
+        _req.url = typeof path === "string" ? path : req.url ? req.url.path || req.url : void 0;
+      }
+      if (req.query) {
+        _req.query = req.query;
+      }
+      if (req.params) {
+        _req.params = req.params;
+      }
+      _req.headers = req.headers;
+      _req.remoteAddress = connection && connection.remoteAddress;
+      _req.remotePort = connection && connection.remotePort;
+      _req.raw = req.raw || req;
+      return _req;
+    }
+    function mapHttpRequest(req) {
+      return {
+        req: reqSerializer(req)
+      };
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/pino-std-serializers@7.1.0/node_modules/pino-std-serializers/lib/res.js
+var require_res = __commonJS({
+  "../../node_modules/.pnpm/pino-std-serializers@7.1.0/node_modules/pino-std-serializers/lib/res.js"(exports, module) {
+    "use strict";
+    module.exports = {
+      mapHttpResponse,
+      resSerializer
+    };
+    var rawSymbol = /* @__PURE__ */ Symbol("pino-raw-res-ref");
+    var pinoResProto = Object.create({}, {
+      statusCode: {
+        enumerable: true,
+        writable: true,
+        value: 0
+      },
+      headers: {
+        enumerable: true,
+        writable: true,
+        value: ""
+      },
+      raw: {
+        enumerable: false,
+        get: function() {
+          return this[rawSymbol];
+        },
+        set: function(val) {
+          this[rawSymbol] = val;
+        }
+      }
+    });
+    Object.defineProperty(pinoResProto, rawSymbol, {
+      writable: true,
+      value: {}
+    });
+    function resSerializer(res) {
+      const _res = Object.create(pinoResProto);
+      _res.statusCode = res.headersSent ? res.statusCode : null;
+      _res.headers = res.getHeaders ? res.getHeaders() : res._headers;
+      _res.raw = res;
+      return _res;
+    }
+    function mapHttpResponse(res) {
+      return {
+        res: resSerializer(res)
+      };
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/pino-std-serializers@7.1.0/node_modules/pino-std-serializers/index.js
+var require_pino_std_serializers = __commonJS({
+  "../../node_modules/.pnpm/pino-std-serializers@7.1.0/node_modules/pino-std-serializers/index.js"(exports, module) {
+    "use strict";
+    var errSerializer2 = require_err();
+    var errWithCauseSerializer = require_err_with_cause();
+    var reqSerializers = require_req();
+    var resSerializers = require_res();
+    module.exports = {
+      err: errSerializer2,
+      errWithCause: errWithCauseSerializer,
+      mapHttpRequest: reqSerializers.mapHttpRequest,
+      mapHttpResponse: resSerializers.mapHttpResponse,
+      req: reqSerializers.reqSerializer,
+      res: resSerializers.resSerializer,
+      wrapErrorSerializer: function wrapErrorSerializer(customSerializer) {
+        if (customSerializer === errSerializer2) return customSerializer;
+        return function wrapErrSerializer(err) {
+          return customSerializer(errSerializer2(err));
+        };
+      },
+      wrapRequestSerializer: function wrapRequestSerializer(customSerializer) {
+        if (customSerializer === reqSerializers.reqSerializer) return customSerializer;
+        return function wrappedReqSerializer(req) {
+          return customSerializer(reqSerializers.reqSerializer(req));
+        };
+      },
+      wrapResponseSerializer: function wrapResponseSerializer(customSerializer) {
+        if (customSerializer === resSerializers.resSerializer) return customSerializer;
+        return function wrappedResSerializer(res) {
+          return customSerializer(resSerializers.resSerializer(res));
+        };
+      }
+    };
+  }
+});
+
+// ../shared-common/dist/index.js
+var import_pino = __toESM(require_browser(), 1);
+var import_pino_std_serializers = __toESM(require_pino_std_serializers(), 1);
+var readEnv = (key) => typeof process !== "undefined" ? process.env?.[key] : void 0;
+var isBrowser = typeof window !== "undefined";
+var isDevelopment = readEnv("NODE_ENV") !== "production";
+var baseLogger = (0, import_pino.default)({
+  level: readEnv("LOG_LEVEL") || "info",
+  formatters: {
+    level: (label) => ({ level: label })
+  },
+  serializers: {
+    error: import_pino_std_serializers.err,
+    err: import_pino_std_serializers.err
+  },
+  // Pretty printing runs pino-pretty in a worker thread, which exists only on
+  // Node. Bundlers resolve `pino` to its browser build, where `transport` is
+  // ignored anyway — but the guard keeps the intent explicit and stops a
+  // non-browser-aware bundler from trying to pull pino-pretty into a web bundle.
+  transport: !isBrowser && isDevelopment ? {
+    target: "pino-pretty",
+    options: {
+      colorize: true,
+      translateTime: "SYS:standard",
+      ignore: "pid,hostname"
+    }
+  } : void 0,
+  // Browser build: emit the structured record to the console rather than a
+  // formatted string, so the fields stay inspectable in devtools.
+  browser: {
+    asObject: true
+  }
+});
+var createLogger = (module) => {
+  return baseLogger.child({ module });
+};
+var VALID_LEVELS = ["trace", "debug", "info", "warn", "error", "fatal"];
+var consoleLogLevel = VALID_LEVELS.includes(readEnv("CONSOLE_LOG_LEVEL") ?? "") ? readEnv("CONSOLE_LOG_LEVEL") : "info";
+
+export {
+  createLogger
+};
+//# sourceMappingURL=chunk-LFKJR7WX.js.map