@mestreyoda/fabrica 0.2.16 → 0.2.17

package/dist/index.js

@@ -1,12 +1,3 @@
-import { createRequire as __oc_createRequire } from "module";
-import { fileURLToPath as __oc_fileURLToPath } from "url";
-import { dirname as __oc_dirname, join as __oc_join } from "path";
-const __oc_filename = __oc_fileURLToPath(import.meta.url);
-const __oc_dirnameVal = __oc_dirname(__oc_filename);
-globalThis.__bundlerPathsOverrides = {
-  "thread-stream-worker": __oc_join(__oc_dirnameVal, "lib", "worker.cjs"),
-  "pino-worker": __oc_join(__oc_dirnameVal, "worker.cjs"),
-};
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -94160,7 +94151,7 @@ var require_thread_stream = __commonJS({
 var require_transport2 = __commonJS({
   "node_modules/pino/lib/transport.js"(exports2, module2) {
     "use strict";
-    var { createRequire: createRequire5 } = __require("module");
+    var { createRequire: createRequire4 } = __require("module");
     var { existsSync: existsSync2 } = __require("node:fs");
     var getCallers = require_caller();
     var { join: join7, isAbsolute, sep } = __require("node:path");
@@ -94363,7 +94354,7 @@ var require_transport2 = __commonJS({
         for (const filePath of callers) {
           try {
             const context2 = filePath === "node:repl" ? process.cwd() + sep : filePath;
-            fixTarget2 = createRequire5(context2).resolve(origin);
+            fixTarget2 = createRequire4(context2).resolve(origin);
             break;
           } catch (err) {
             continue;
@@ -96135,31 +96126,2597 @@ var require_pino = __commonJS({
   }
 });
 
+// node_modules/colorette/index.cjs
+var require_colorette = __commonJS({
+  "node_modules/colorette/index.cjs"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    var tty = __require("tty");
+    function _interopNamespace(e2) {
+      if (e2 && e2.__esModule) return e2;
+      var n = /* @__PURE__ */ Object.create(null);
+      if (e2) {
+        Object.keys(e2).forEach(function(k) {
+          if (k !== "default") {
+            var d = Object.getOwnPropertyDescriptor(e2, k);
+            Object.defineProperty(n, k, d.get ? d : {
+              enumerable: true,
+              get: function() {
+                return e2[k];
+              }
+            });
+          }
+        });
+      }
+      n["default"] = e2;
+      return Object.freeze(n);
+    }
+    var tty__namespace = /* @__PURE__ */ _interopNamespace(tty);
+    var {
+      env = {},
+      argv = [],
+      platform = ""
+    } = typeof process === "undefined" ? {} : process;
+    var isDisabled = "NO_COLOR" in env || argv.includes("--no-color");
+    var isForced = "FORCE_COLOR" in env || argv.includes("--color");
+    var isWindows = platform === "win32";
+    var isDumbTerminal = env.TERM === "dumb";
+    var isCompatibleTerminal = tty__namespace && tty__namespace.isatty && tty__namespace.isatty(1) && env.TERM && !isDumbTerminal;
+    var isCI = "CI" in env && ("GITHUB_ACTIONS" in env || "GITLAB_CI" in env || "CIRCLECI" in env);
+    var isColorSupported = !isDisabled && (isForced || isWindows && !isDumbTerminal || isCompatibleTerminal || isCI);
+    var replaceClose = (index, string4, close, replace, head = string4.substring(0, index) + replace, tail = string4.substring(index + close.length), next = tail.indexOf(close)) => head + (next < 0 ? tail : replaceClose(next, tail, close, replace));
+    var clearBleed = (index, string4, open, close, replace) => index < 0 ? open + string4 + close : open + replaceClose(index, string4, close, replace) + close;
+    var filterEmpty = (open, close, replace = open, at = open.length + 1) => (string4) => string4 || !(string4 === "" || string4 === void 0) ? clearBleed(
+      ("" + string4).indexOf(close, at),
+      string4,
+      open,
+      close,
+      replace
+    ) : "";
+    var init = (open, close, replace) => filterEmpty(`\x1B[${open}m`, `\x1B[${close}m`, replace);
+    var colors = {
+      reset: init(0, 0),
+      bold: init(1, 22, "\x1B[22m\x1B[1m"),
+      dim: init(2, 22, "\x1B[22m\x1B[2m"),
+      italic: init(3, 23),
+      underline: init(4, 24),
+      inverse: init(7, 27),
+      hidden: init(8, 28),
+      strikethrough: init(9, 29),
+      black: init(30, 39),
+      red: init(31, 39),
+      green: init(32, 39),
+      yellow: init(33, 39),
+      blue: init(34, 39),
+      magenta: init(35, 39),
+      cyan: init(36, 39),
+      white: init(37, 39),
+      gray: init(90, 39),
+      bgBlack: init(40, 49),
+      bgRed: init(41, 49),
+      bgGreen: init(42, 49),
+      bgYellow: init(43, 49),
+      bgBlue: init(44, 49),
+      bgMagenta: init(45, 49),
+      bgCyan: init(46, 49),
+      bgWhite: init(47, 49),
+      blackBright: init(90, 39),
+      redBright: init(91, 39),
+      greenBright: init(92, 39),
+      yellowBright: init(93, 39),
+      blueBright: init(94, 39),
+      magentaBright: init(95, 39),
+      cyanBright: init(96, 39),
+      whiteBright: init(97, 39),
+      bgBlackBright: init(100, 49),
+      bgRedBright: init(101, 49),
+      bgGreenBright: init(102, 49),
+      bgYellowBright: init(103, 49),
+      bgBlueBright: init(104, 49),
+      bgMagentaBright: init(105, 49),
+      bgCyanBright: init(106, 49),
+      bgWhiteBright: init(107, 49)
+    };
+    var createColors = ({ useColor = isColorSupported } = {}) => useColor ? colors : Object.keys(colors).reduce(
+      (colors2, key) => ({ ...colors2, [key]: String }),
+      {}
+    );
+    var {
+      reset,
+      bold,
+      dim,
+      italic,
+      underline,
+      inverse,
+      hidden,
+      strikethrough,
+      black,
+      red,
+      green,
+      yellow,
+      blue,
+      magenta,
+      cyan,
+      white,
+      gray,
+      bgBlack,
+      bgRed,
+      bgGreen,
+      bgYellow,
+      bgBlue,
+      bgMagenta,
+      bgCyan,
+      bgWhite,
+      blackBright,
+      redBright,
+      greenBright,
+      yellowBright,
+      blueBright,
+      magentaBright,
+      cyanBright,
+      whiteBright,
+      bgBlackBright,
+      bgRedBright,
+      bgGreenBright,
+      bgYellowBright,
+      bgBlueBright,
+      bgMagentaBright,
+      bgCyanBright,
+      bgWhiteBright
+    } = createColors();
+    exports2.bgBlack = bgBlack;
+    exports2.bgBlackBright = bgBlackBright;
+    exports2.bgBlue = bgBlue;
+    exports2.bgBlueBright = bgBlueBright;
+    exports2.bgCyan = bgCyan;
+    exports2.bgCyanBright = bgCyanBright;
+    exports2.bgGreen = bgGreen;
+    exports2.bgGreenBright = bgGreenBright;
+    exports2.bgMagenta = bgMagenta;
+    exports2.bgMagentaBright = bgMagentaBright;
+    exports2.bgRed = bgRed;
+    exports2.bgRedBright = bgRedBright;
+    exports2.bgWhite = bgWhite;
+    exports2.bgWhiteBright = bgWhiteBright;
+    exports2.bgYellow = bgYellow;
+    exports2.bgYellowBright = bgYellowBright;
+    exports2.black = black;
+    exports2.blackBright = blackBright;
+    exports2.blue = blue;
+    exports2.blueBright = blueBright;
+    exports2.bold = bold;
+    exports2.createColors = createColors;
+    exports2.cyan = cyan;
+    exports2.cyanBright = cyanBright;
+    exports2.dim = dim;
+    exports2.gray = gray;
+    exports2.green = green;
+    exports2.greenBright = greenBright;
+    exports2.hidden = hidden;
+    exports2.inverse = inverse;
+    exports2.isColorSupported = isColorSupported;
+    exports2.italic = italic;
+    exports2.magenta = magenta;
+    exports2.magentaBright = magentaBright;
+    exports2.red = red;
+    exports2.redBright = redBright;
+    exports2.reset = reset;
+    exports2.strikethrough = strikethrough;
+    exports2.underline = underline;
+    exports2.white = white;
+    exports2.whiteBright = whiteBright;
+    exports2.yellow = yellow;
+    exports2.yellowBright = yellowBright;
+  }
+});
+
+// node_modules/wrappy/wrappy.js
+var require_wrappy = __commonJS({
+  "node_modules/wrappy/wrappy.js"(exports2, module2) {
+    module2.exports = wrappy;
+    function wrappy(fn, cb) {
+      if (fn && cb) return wrappy(fn)(cb);
+      if (typeof fn !== "function")
+        throw new TypeError("need wrapper function");
+      Object.keys(fn).forEach(function(k) {
+        wrapper[k] = fn[k];
+      });
+      return wrapper;
+      function wrapper() {
+        var args = new Array(arguments.length);
+        for (var i2 = 0; i2 < args.length; i2++) {
+          args[i2] = arguments[i2];
+        }
+        var ret = fn.apply(this, args);
+        var cb2 = args[args.length - 1];
+        if (typeof ret === "function" && ret !== cb2) {
+          Object.keys(cb2).forEach(function(k) {
+            ret[k] = cb2[k];
+          });
+        }
+        return ret;
+      }
+    }
+  }
+});
+
+// node_modules/once/once.js
+var require_once = __commonJS({
+  "node_modules/once/once.js"(exports2, module2) {
+    var wrappy = require_wrappy();
+    module2.exports = wrappy(once);
+    module2.exports.strict = wrappy(onceStrict);
+    once.proto = once(function() {
+      Object.defineProperty(Function.prototype, "once", {
+        value: function() {
+          return once(this);
+        },
+        configurable: true
+      });
+      Object.defineProperty(Function.prototype, "onceStrict", {
+        value: function() {
+          return onceStrict(this);
+        },
+        configurable: true
+      });
+    });
+    function once(fn) {
+      var f3 = function() {
+        if (f3.called) return f3.value;
+        f3.called = true;
+        return f3.value = fn.apply(this, arguments);
+      };
+      f3.called = false;
+      return f3;
+    }
+    function onceStrict(fn) {
+      var f3 = function() {
+        if (f3.called)
+          throw new Error(f3.onceError);
+        f3.called = true;
+        return f3.value = fn.apply(this, arguments);
+      };
+      var name = fn.name || "Function wrapped with `once`";
+      f3.onceError = name + " shouldn't be called more than once";
+      f3.called = false;
+      return f3;
+    }
+  }
+});
+
+// node_modules/end-of-stream/index.js
+var require_end_of_stream = __commonJS({
+  "node_modules/end-of-stream/index.js"(exports2, module2) {
+    var once = require_once();
+    var noop2 = function() {
+    };
+    var qnt = global.Bare ? queueMicrotask : process.nextTick.bind(process);
+    var isRequest2 = function(stream) {
+      return stream.setHeader && typeof stream.abort === "function";
+    };
+    var isChildProcess = function(stream) {
+      return stream.stdio && Array.isArray(stream.stdio) && stream.stdio.length === 3;
+    };
+    var eos = function(stream, opts, callback) {
+      if (typeof opts === "function") return eos(stream, null, opts);
+      if (!opts) opts = {};
+      callback = once(callback || noop2);
+      var ws = stream._writableState;
+      var rs = stream._readableState;
+      var readable = opts.readable || opts.readable !== false && stream.readable;
+      var writable = opts.writable || opts.writable !== false && stream.writable;
+      var cancelled = false;
+      var onlegacyfinish = function() {
+        if (!stream.writable) onfinish();
+      };
+      var onfinish = function() {
+        writable = false;
+        if (!readable) callback.call(stream);
+      };
+      var onend = function() {
+        readable = false;
+        if (!writable) callback.call(stream);
+      };
+      var onexit = function(exitCode) {
+        callback.call(stream, exitCode ? new Error("exited with error code: " + exitCode) : null);
+      };
+      var onerror = function(err) {
+        callback.call(stream, err);
+      };
+      var onclose = function() {
+        qnt(onclosenexttick);
+      };
+      var onclosenexttick = function() {
+        if (cancelled) return;
+        if (readable && !(rs && (rs.ended && !rs.destroyed))) return callback.call(stream, new Error("premature close"));
+        if (writable && !(ws && (ws.ended && !ws.destroyed))) return callback.call(stream, new Error("premature close"));
+      };
+      var onrequest = function() {
+        stream.req.on("finish", onfinish);
+      };
+      if (isRequest2(stream)) {
+        stream.on("complete", onfinish);
+        stream.on("abort", onclose);
+        if (stream.req) onrequest();
+        else stream.on("request", onrequest);
+      } else if (writable && !ws) {
+        stream.on("end", onlegacyfinish);
+        stream.on("close", onlegacyfinish);
+      }
+      if (isChildProcess(stream)) stream.on("exit", onexit);
+      stream.on("end", onend);
+      stream.on("finish", onfinish);
+      if (opts.error !== false) stream.on("error", onerror);
+      stream.on("close", onclose);
+      return function() {
+        cancelled = true;
+        stream.removeListener("complete", onfinish);
+        stream.removeListener("abort", onclose);
+        stream.removeListener("request", onrequest);
+        if (stream.req) stream.req.removeListener("finish", onfinish);
+        stream.removeListener("end", onlegacyfinish);
+        stream.removeListener("close", onlegacyfinish);
+        stream.removeListener("finish", onfinish);
+        stream.removeListener("exit", onexit);
+        stream.removeListener("end", onend);
+        stream.removeListener("error", onerror);
+        stream.removeListener("close", onclose);
+      };
+    };
+    module2.exports = eos;
+  }
+});
+
+// node_modules/pump/index.js
+var require_pump = __commonJS({
+  "node_modules/pump/index.js"(exports2, module2) {
+    var once = require_once();
+    var eos = require_end_of_stream();
+    var fs45;
+    try {
+      fs45 = __require("fs");
+    } catch (e2) {
+    }
+    var noop2 = function() {
+    };
+    var ancient = typeof process === "undefined" ? false : /^v?\.0/.test(process.version);
+    var isFn = function(fn) {
+      return typeof fn === "function";
+    };
+    var isFS = function(stream) {
+      if (!ancient) return false;
+      if (!fs45) return false;
+      return (stream instanceof (fs45.ReadStream || noop2) || stream instanceof (fs45.WriteStream || noop2)) && isFn(stream.close);
+    };
+    var isRequest2 = function(stream) {
+      return stream.setHeader && isFn(stream.abort);
+    };
+    var destroyer = function(stream, reading, writing, callback) {
+      callback = once(callback);
+      var closed = false;
+      stream.on("close", function() {
+        closed = true;
+      });
+      eos(stream, { readable: reading, writable: writing }, function(err) {
+        if (err) return callback(err);
+        closed = true;
+        callback();
+      });
+      var destroyed = false;
+      return function(err) {
+        if (closed) return;
+        if (destroyed) return;
+        destroyed = true;
+        if (isFS(stream)) return stream.close(noop2);
+        if (isRequest2(stream)) return stream.abort();
+        if (isFn(stream.destroy)) return stream.destroy();
+        callback(err || new Error("stream was destroyed"));
+      };
+    };
+    var call = function(fn) {
+      fn();
+    };
+    var pipe2 = function(from, to) {
+      return from.pipe(to);
+    };
+    var pump2 = function() {
+      var streams = Array.prototype.slice.call(arguments);
+      var callback = isFn(streams[streams.length - 1] || noop2) && streams.pop() || noop2;
+      if (Array.isArray(streams[0])) streams = streams[0];
+      if (streams.length < 2) throw new Error("pump requires two streams per minimum");
+      var error48;
+      var destroys = streams.map(function(stream, i2) {
+        var reading = i2 < streams.length - 1;
+        var writing = i2 > 0;
+        return destroyer(stream, reading, writing, function(err) {
+          if (!error48) error48 = err;
+          if (err) destroys.forEach(call);
+          if (reading) return;
+          destroys.forEach(call);
+          callback(error48);
+        });
+      });
+      return streams.reduce(pipe2);
+    };
+    module2.exports = pump2;
+  }
+});
+
+// node_modules/split2/index.js
+var require_split2 = __commonJS({
+  "node_modules/split2/index.js"(exports2, module2) {
+    "use strict";
+    var { Transform } = __require("stream");
+    var { StringDecoder } = __require("string_decoder");
+    var kLast = Symbol("last");
+    var kDecoder = Symbol("decoder");
+    function transform2(chunk, enc, cb) {
+      let list;
+      if (this.overflow) {
+        const buf = this[kDecoder].write(chunk);
+        list = buf.split(this.matcher);
+        if (list.length === 1) return cb();
+        list.shift();
+        this.overflow = false;
+      } else {
+        this[kLast] += this[kDecoder].write(chunk);
+        list = this[kLast].split(this.matcher);
+      }
+      this[kLast] = list.pop();
+      for (let i2 = 0; i2 < list.length; i2++) {
+        try {
+          push(this, this.mapper(list[i2]));
+        } catch (error48) {
+          return cb(error48);
+        }
+      }
+      this.overflow = this[kLast].length > this.maxLength;
+      if (this.overflow && !this.skipOverflow) {
+        cb(new Error("maximum buffer reached"));
+        return;
+      }
+      cb();
+    }
+    function flush(cb) {
+      this[kLast] += this[kDecoder].end();
+      if (this[kLast]) {
+        try {
+          push(this, this.mapper(this[kLast]));
+        } catch (error48) {
+          return cb(error48);
+        }
+      }
+      cb();
+    }
+    function push(self2, val) {
+      if (val !== void 0) {
+        self2.push(val);
+      }
+    }
+    function noop2(incoming) {
+      return incoming;
+    }
+    function split(matcher, mapper, options) {
+      matcher = matcher || /\r?\n/;
+      mapper = mapper || noop2;
+      options = options || {};
+      switch (arguments.length) {
+        case 1:
+          if (typeof matcher === "function") {
+            mapper = matcher;
+            matcher = /\r?\n/;
+          } else if (typeof matcher === "object" && !(matcher instanceof RegExp) && !matcher[Symbol.split]) {
+            options = matcher;
+            matcher = /\r?\n/;
+          }
+          break;
+        case 2:
+          if (typeof matcher === "function") {
+            options = mapper;
+            mapper = matcher;
+            matcher = /\r?\n/;
+          } else if (typeof mapper === "object") {
+            options = mapper;
+            mapper = noop2;
+          }
+      }
+      options = Object.assign({}, options);
+      options.autoDestroy = true;
+      options.transform = transform2;
+      options.flush = flush;
+      options.readableObjectMode = true;
+      const stream = new Transform(options);
+      stream[kLast] = "";
+      stream[kDecoder] = new StringDecoder("utf8");
+      stream.matcher = matcher;
+      stream.mapper = mapper;
+      stream.maxLength = options.maxLength;
+      stream.skipOverflow = options.skipOverflow || false;
+      stream.overflow = false;
+      stream._destroy = function(err, cb) {
+        this._writableState.errorEmitted = false;
+        cb(err);
+      };
+      return stream;
+    }
+    module2.exports = split;
+  }
+});
+
+// node_modules/pino-abstract-transport/index.js
+var require_pino_abstract_transport = __commonJS({
+  "node_modules/pino-abstract-transport/index.js"(exports2, module2) {
+    "use strict";
+    var metadata = Symbol.for("pino.metadata");
+    var split = require_split2();
+    var { Duplex } = __require("stream");
+    var { parentPort, workerData } = __require("worker_threads");
+    function createDeferred() {
+      let resolve3;
+      let reject;
+      const promise2 = new Promise((_resolve, _reject) => {
+        resolve3 = _resolve;
+        reject = _reject;
+      });
+      promise2.resolve = resolve3;
+      promise2.reject = reject;
+      return promise2;
+    }
+    module2.exports = function build(fn, opts = {}) {
+      const waitForConfig = opts.expectPinoConfig === true && workerData?.workerData?.pinoWillSendConfig === true;
+      const parseLines = opts.parse === "lines";
+      const parseLine = typeof opts.parseLine === "function" ? opts.parseLine : JSON.parse;
+      const close = opts.close || defaultClose;
+      const stream = split(function(line) {
+        let value;
+        try {
+          value = parseLine(line);
+        } catch (error48) {
+          this.emit("unknown", line, error48);
+          return;
+        }
+        if (value === null) {
+          this.emit("unknown", line, "Null value ignored");
+          return;
+        }
+        if (typeof value !== "object") {
+          value = {
+            data: value,
+            time: Date.now()
+          };
+        }
+        if (stream[metadata]) {
+          stream.lastTime = value.time;
+          stream.lastLevel = value.level;
+          stream.lastObj = value;
+        }
+        if (parseLines) {
+          return line;
+        }
+        return value;
+      }, { autoDestroy: true });
+      stream._destroy = function(err, cb) {
+        const promise2 = close(err, cb);
+        if (promise2 && typeof promise2.then === "function") {
+          promise2.then(cb, cb);
+        }
+      };
+      if (opts.expectPinoConfig === true && workerData?.workerData?.pinoWillSendConfig !== true) {
+        setImmediate(() => {
+          stream.emit("error", new Error("This transport is not compatible with the current version of pino. Please upgrade pino to the latest version."));
+        });
+      }
+      if (opts.metadata !== false) {
+        stream[metadata] = true;
+        stream.lastTime = 0;
+        stream.lastLevel = 0;
+        stream.lastObj = null;
+      }
+      if (waitForConfig) {
+        let pinoConfig = {};
+        const configReceived = createDeferred();
+        parentPort.on("message", function handleMessage(message) {
+          if (message.code === "PINO_CONFIG") {
+            pinoConfig = message.config;
+            configReceived.resolve();
+            parentPort.off("message", handleMessage);
+          }
+        });
+        Object.defineProperties(stream, {
+          levels: {
+            get() {
+              return pinoConfig.levels;
+            }
+          },
+          messageKey: {
+            get() {
+              return pinoConfig.messageKey;
+            }
+          },
+          errorKey: {
+            get() {
+              return pinoConfig.errorKey;
+            }
+          }
+        });
+        return configReceived.then(finish);
+      }
+      return finish();
+      function finish() {
+        let res = fn(stream);
+        if (res && typeof res.catch === "function") {
+          res.catch((err) => {
+            stream.destroy(err);
+          });
+          res = null;
+        } else if (opts.enablePipelining && res) {
+          return Duplex.from({ writable: stream, readable: res });
+        }
+        return stream;
+      }
+    };
+    function defaultClose(err, cb) {
+      process.nextTick(cb, err);
+    }
+  }
+});
+
+// node_modules/pino-pretty/lib/constants.js
+var require_constants11 = __commonJS({
+  "node_modules/pino-pretty/lib/constants.js"(exports2, module2) {
+    "use strict";
+    module2.exports = {
+      DATE_FORMAT: "yyyy-mm-dd HH:MM:ss.l o",
+      DATE_FORMAT_SIMPLE: "HH:MM:ss.l",
+      /**
+       * @type {K_ERROR_LIKE_KEYS}
+       */
+      ERROR_LIKE_KEYS: ["err", "error"],
+      MESSAGE_KEY: "msg",
+      LEVEL_KEY: "level",
+      LEVEL_LABEL: "levelLabel",
+      TIMESTAMP_KEY: "time",
+      LEVELS: {
+        default: "USERLVL",
+        60: "FATAL",
+        50: "ERROR",
+        40: "WARN",
+        30: "INFO",
+        20: "DEBUG",
+        10: "TRACE"
+      },
+      LEVEL_NAMES: {
+        fatal: 60,
+        error: 50,
+        warn: 40,
+        info: 30,
+        debug: 20,
+        trace: 10
+      },
+      // Object keys that probably came from a logger like Pino or Bunyan.
+      LOGGER_KEYS: [
+        "pid",
+        "hostname",
+        "name",
+        "level",
+        "time",
+        "timestamp",
+        "caller"
+      ]
+    };
+  }
+});
+
+// node_modules/pino-pretty/lib/utils/get-level-label-data.js
+var require_get_level_label_data = __commonJS({
+  "node_modules/pino-pretty/lib/utils/get-level-label-data.js"(exports2, module2) {
+    "use strict";
+    module2.exports = getLevelLabelData;
+    var { LEVELS, LEVEL_NAMES } = require_constants11();
+    function getLevelLabelData(useOnlyCustomProps, customLevels, customLevelNames) {
+      const levels = useOnlyCustomProps ? customLevels || LEVELS : Object.assign({}, LEVELS, customLevels);
+      const levelNames = useOnlyCustomProps ? customLevelNames || LEVEL_NAMES : Object.assign({}, LEVEL_NAMES, customLevelNames);
+      return function(level) {
+        let levelNum = "default";
+        if (Number.isInteger(+level)) {
+          levelNum = Object.prototype.hasOwnProperty.call(levels, level) ? level : levelNum;
+        } else {
+          levelNum = Object.prototype.hasOwnProperty.call(levelNames, level.toLowerCase()) ? levelNames[level.toLowerCase()] : levelNum;
+        }
+        return [levels[levelNum], levelNum];
+      };
+    }
+  }
+});
+
+// node_modules/pino-pretty/lib/colors.js
+var require_colors = __commonJS({
+  "node_modules/pino-pretty/lib/colors.js"(exports2, module2) {
+    "use strict";
+    var nocolor = (input) => input;
+    var plain = {
+      default: nocolor,
+      60: nocolor,
+      50: nocolor,
+      40: nocolor,
+      30: nocolor,
+      20: nocolor,
+      10: nocolor,
+      message: nocolor,
+      greyMessage: nocolor,
+      property: nocolor
+    };
+    var { createColors } = require_colorette();
+    var getLevelLabelData = require_get_level_label_data();
+    var availableColors = createColors({ useColor: true });
+    var { white, bgRed, red, yellow, green, blue, gray, cyan, magenta } = availableColors;
+    var colored = {
+      default: white,
+      60: bgRed,
+      50: red,
+      40: yellow,
+      30: green,
+      20: blue,
+      10: gray,
+      message: cyan,
+      greyMessage: gray,
+      property: magenta
+    };
+    function resolveCustomColoredColorizer(customColors) {
+      return customColors.reduce(
+        function(agg, [level, color]) {
+          agg[level] = typeof availableColors[color] === "function" ? availableColors[color] : white;
+          return agg;
+        },
+        { default: white, message: cyan, greyMessage: gray, property: magenta }
+      );
+    }
+    function colorizeLevel(useOnlyCustomProps) {
+      return function(level, colorizer, { customLevels, customLevelNames } = {}) {
+        const [levelStr, levelNum] = getLevelLabelData(useOnlyCustomProps, customLevels, customLevelNames)(level);
+        return Object.prototype.hasOwnProperty.call(colorizer, levelNum) ? colorizer[levelNum](levelStr) : colorizer.default(levelStr);
+      };
+    }
+    function plainColorizer(useOnlyCustomProps) {
+      const newPlainColorizer = colorizeLevel(useOnlyCustomProps);
+      const customColoredColorizer = function(level, opts) {
+        return newPlainColorizer(level, plain, opts);
+      };
+      customColoredColorizer.message = plain.message;
+      customColoredColorizer.greyMessage = plain.greyMessage;
+      customColoredColorizer.property = plain.property;
+      customColoredColorizer.colors = createColors({ useColor: false });
+      return customColoredColorizer;
+    }
+    function coloredColorizer(useOnlyCustomProps) {
+      const newColoredColorizer = colorizeLevel(useOnlyCustomProps);
+      const customColoredColorizer = function(level, opts) {
+        return newColoredColorizer(level, colored, opts);
+      };
+      customColoredColorizer.message = colored.message;
+      customColoredColorizer.property = colored.property;
+      customColoredColorizer.greyMessage = colored.greyMessage;
+      customColoredColorizer.colors = availableColors;
+      return customColoredColorizer;
+    }
+    function customColoredColorizerFactory(customColors, useOnlyCustomProps) {
+      const onlyCustomColored = resolveCustomColoredColorizer(customColors);
+      const customColored = useOnlyCustomProps ? onlyCustomColored : Object.assign({}, colored, onlyCustomColored);
+      const colorizeLevelCustom = colorizeLevel(useOnlyCustomProps);
+      const customColoredColorizer = function(level, opts) {
+        return colorizeLevelCustom(level, customColored, opts);
+      };
+      customColoredColorizer.colors = availableColors;
+      customColoredColorizer.message = customColoredColorizer.message || customColored.message;
+      customColoredColorizer.property = customColoredColorizer.property || customColored.property;
+      customColoredColorizer.greyMessage = customColoredColorizer.greyMessage || customColored.greyMessage;
+      return customColoredColorizer;
+    }
+    module2.exports = function getColorizer(useColors = false, customColors, useOnlyCustomProps) {
+      if (useColors && customColors !== void 0) {
+        return customColoredColorizerFactory(customColors, useOnlyCustomProps);
+      } else if (useColors) {
+        return coloredColorizer(useOnlyCustomProps);
+      }
+      return plainColorizer(useOnlyCustomProps);
+    };
+  }
+});
+
+// node_modules/pino-pretty/lib/utils/noop.js
+var require_noop = __commonJS({
+  "node_modules/pino-pretty/lib/utils/noop.js"(exports2, module2) {
+    "use strict";
+    module2.exports = function noop2() {
+    };
+  }
+});
+
+// node_modules/pino-pretty/lib/utils/build-safe-sonic-boom.js
+var require_build_safe_sonic_boom = __commonJS({
+  "node_modules/pino-pretty/lib/utils/build-safe-sonic-boom.js"(exports2, module2) {
+    "use strict";
+    module2.exports = buildSafeSonicBoom;
+    var { isMainThread } = __require("node:worker_threads");
+    var SonicBoom = require_sonic_boom();
+    var noop2 = require_noop();
+    function buildSafeSonicBoom(opts) {
+      const stream = new SonicBoom(opts);
+      stream.on("error", filterBrokenPipe);
+      if (!opts.sync && isMainThread) {
+        setupOnExit(stream);
+      }
+      return stream;
+      function filterBrokenPipe(err) {
+        if (err.code === "EPIPE") {
+          stream.write = noop2;
+          stream.end = noop2;
+          stream.flushSync = noop2;
+          stream.destroy = noop2;
+          return;
+        }
+        stream.removeListener("error", filterBrokenPipe);
+      }
+    }
+    function setupOnExit(stream) {
+      if (global.WeakRef && global.WeakMap && global.FinalizationRegistry) {
+        const onExit = require_on_exit_leak_free();
+        onExit.register(stream, autoEnd);
+        stream.on("close", function() {
+          onExit.unregister(stream);
+        });
+      }
+    }
+    function autoEnd(stream, eventName) {
+      if (stream.destroyed) {
+        return;
+      }
+      if (eventName === "beforeExit") {
+        stream.flush();
+        stream.on("drain", function() {
+          stream.end();
+        });
+      } else {
+        stream.flushSync();
+      }
+    }
+  }
+});
+
+// node_modules/pino-pretty/lib/utils/is-valid-date.js
+var require_is_valid_date = __commonJS({
+  "node_modules/pino-pretty/lib/utils/is-valid-date.js"(exports2, module2) {
+    "use strict";
+    module2.exports = isValidDate;
+    function isValidDate(date5) {
+      return date5 instanceof Date && !Number.isNaN(date5.getTime());
+    }
+  }
+});
+
+// node_modules/pino-pretty/lib/utils/create-date.js
+var require_create_date = __commonJS({
+  "node_modules/pino-pretty/lib/utils/create-date.js"(exports2, module2) {
+    "use strict";
+    module2.exports = createDate;
+    var isValidDate = require_is_valid_date();
+    function createDate(epoch) {
+      let date5 = new Date(epoch);
+      if (isValidDate(date5)) {
+        return date5;
+      }
+      date5 = /* @__PURE__ */ new Date(+epoch);
+      return date5;
+    }
+  }
+});
+
+// node_modules/pino-pretty/lib/utils/split-property-key.js
+var require_split_property_key = __commonJS({
+  "node_modules/pino-pretty/lib/utils/split-property-key.js"(exports2, module2) {
+    "use strict";
+    module2.exports = splitPropertyKey;
+    function splitPropertyKey(key) {
+      const result = [];
+      let backslash = false;
+      let segment = "";
+      for (let i2 = 0; i2 < key.length; i2++) {
+        const c = key.charAt(i2);
+        if (c === "\\") {
+          backslash = true;
+          continue;
+        }
+        if (backslash) {
+          backslash = false;
+          segment += c;
+          continue;
+        }
+        if (c === ".") {
+          result.push(segment);
+          segment = "";
+          continue;
+        }
+        segment += c;
+      }
+      if (segment.length) {
+        result.push(segment);
+      }
+      return result;
+    }
+  }
+});
+
+// node_modules/pino-pretty/lib/utils/get-property-value.js
+var require_get_property_value = __commonJS({
+  "node_modules/pino-pretty/lib/utils/get-property-value.js"(exports2, module2) {
+    "use strict";
+    module2.exports = getPropertyValue;
+    var splitPropertyKey = require_split_property_key();
+    function getPropertyValue(obj, property) {
+      const props = Array.isArray(property) ? property : splitPropertyKey(property);
+      for (const prop of props) {
+        if (!Object.prototype.hasOwnProperty.call(obj, prop)) {
+          return;
+        }
+        obj = obj[prop];
+      }
+      return obj;
+    }
+  }
+});
+
+// node_modules/pino-pretty/lib/utils/delete-log-property.js
+var require_delete_log_property = __commonJS({
+  "node_modules/pino-pretty/lib/utils/delete-log-property.js"(exports2, module2) {
+    "use strict";
+    module2.exports = deleteLogProperty;
+    var getPropertyValue = require_get_property_value();
+    var splitPropertyKey = require_split_property_key();
+    function deleteLogProperty(log3, property) {
+      const props = splitPropertyKey(property);
+      const propToDelete = props.pop();
+      log3 = getPropertyValue(log3, props);
+      if (log3 !== null && typeof log3 === "object" && Object.prototype.hasOwnProperty.call(log3, propToDelete)) {
+        delete log3[propToDelete];
+      }
+    }
+  }
+});
+
+// node_modules/fast-copy/dist/cjs/index.cjs
+var require_cjs2 = __commonJS({
+  "node_modules/fast-copy/dist/cjs/index.cjs"(exports2) {
+    "use strict";
+    var toStringFunction = Function.prototype.toString;
+    var toStringObject = Object.prototype.toString;
+    function getCleanClone(prototype) {
+      if (!prototype) {
+        return /* @__PURE__ */ Object.create(null);
+      }
+      const Constructor = prototype.constructor;
+      if (Constructor === Object) {
+        return prototype === Object.prototype ? {} : Object.create(prototype);
+      }
+      if (Constructor && ~toStringFunction.call(Constructor).indexOf("[native code]")) {
+        try {
+          return new Constructor();
+        } catch (_a2) {
+        }
+      }
+      return Object.create(prototype);
+    }
+    function getTag(value) {
+      const stringTag = value[Symbol.toStringTag];
+      if (stringTag) {
+        return stringTag;
+      }
+      const type = toStringObject.call(value);
+      return type.substring(8, type.length - 1);
+    }
+    var { hasOwnProperty, propertyIsEnumerable } = Object.prototype;
+    function copyOwnDescriptor(original, clone3, property, state) {
+      const ownDescriptor = Object.getOwnPropertyDescriptor(original, property) || {
+        configurable: true,
+        enumerable: true,
+        value: original[property],
+        writable: true
+      };
+      const descriptor = ownDescriptor.get || ownDescriptor.set ? ownDescriptor : {
+        configurable: ownDescriptor.configurable,
+        enumerable: ownDescriptor.enumerable,
+        value: state.copier(ownDescriptor.value, state),
+        writable: ownDescriptor.writable
+      };
+      try {
+        Object.defineProperty(clone3, property, descriptor);
+      } catch (_a2) {
+        clone3[property] = descriptor.get ? descriptor.get() : descriptor.value;
+      }
+    }
+    function copyOwnPropertiesStrict(value, clone3, state) {
+      const names = Object.getOwnPropertyNames(value);
+      for (let index = 0; index < names.length; ++index) {
+        copyOwnDescriptor(value, clone3, names[index], state);
+      }
+      const symbols = Object.getOwnPropertySymbols(value);
+      for (let index = 0; index < symbols.length; ++index) {
+        copyOwnDescriptor(value, clone3, symbols[index], state);
+      }
+      return clone3;
+    }
+    function copyArrayLoose(array2, state) {
+      const clone3 = new state.Constructor();
+      state.cache.set(array2, clone3);
+      for (let index = 0; index < array2.length; ++index) {
+        clone3[index] = state.copier(array2[index], state);
+      }
+      return clone3;
+    }
+    function copyArrayStrict(array2, state) {
+      const clone3 = new state.Constructor();
+      state.cache.set(array2, clone3);
+      return copyOwnPropertiesStrict(array2, clone3, state);
+    }
+    function copyArrayBuffer(arrayBuffer, _state) {
+      return arrayBuffer.slice(0);
+    }
+    function copyBlob(blob, _state) {
+      return blob.slice(0, blob.size, blob.type);
+    }
+    function copyDataView(dataView, state) {
+      return new state.Constructor(copyArrayBuffer(dataView.buffer));
+    }
+    function copyDate(date5, state) {
+      return new state.Constructor(date5.getTime());
+    }
+    function copyMapLoose(map2, state) {
+      const clone3 = new state.Constructor();
+      state.cache.set(map2, clone3);
+      map2.forEach((value, key) => {
+        clone3.set(key, state.copier(value, state));
+      });
+      return clone3;
+    }
+    function copyMapStrict(map2, state) {
+      return copyOwnPropertiesStrict(map2, copyMapLoose(map2, state), state);
+    }
+    function copyObjectLoose(object2, state) {
+      const clone3 = getCleanClone(state.prototype);
+      state.cache.set(object2, clone3);
+      for (const key in object2) {
+        if (hasOwnProperty.call(object2, key)) {
+          clone3[key] = state.copier(object2[key], state);
+        }
+      }
+      const symbols = Object.getOwnPropertySymbols(object2);
+      for (let index = 0; index < symbols.length; ++index) {
+        const symbol2 = symbols[index];
+        if (propertyIsEnumerable.call(object2, symbol2)) {
+          clone3[symbol2] = state.copier(object2[symbol2], state);
+        }
+      }
+      return clone3;
+    }
+    function copyObjectStrict(object2, state) {
+      const clone3 = getCleanClone(state.prototype);
+      state.cache.set(object2, clone3);
+      return copyOwnPropertiesStrict(object2, clone3, state);
+    }
+    function copyPrimitiveWrapper(primitiveObject, state) {
+      return new state.Constructor(primitiveObject.valueOf());
+    }
+    function copyRegExp(regExp, state) {
+      const clone3 = new state.Constructor(regExp.source, regExp.flags);
+      clone3.lastIndex = regExp.lastIndex;
+      return clone3;
+    }
+    function copySelf(value, _state) {
+      return value;
+    }
+    function copySetLoose(set2, state) {
+      const clone3 = new state.Constructor();
+      state.cache.set(set2, clone3);
+      set2.forEach((value) => {
+        clone3.add(state.copier(value, state));
+      });
+      return clone3;
+    }
+    function copySetStrict(set2, state) {
+      return copyOwnPropertiesStrict(set2, copySetLoose(set2, state), state);
+    }
+    function createDefaultCache() {
+      return /* @__PURE__ */ new WeakMap();
+    }
+    function getOptions({ createCache: createCacheOverride, methods: methodsOverride, strict }) {
+      const defaultMethods = {
+        array: strict ? copyArrayStrict : copyArrayLoose,
+        arrayBuffer: copyArrayBuffer,
+        asyncGenerator: copySelf,
+        blob: copyBlob,
+        dataView: copyDataView,
+        date: copyDate,
+        error: copySelf,
+        generator: copySelf,
+        map: strict ? copyMapStrict : copyMapLoose,
+        object: strict ? copyObjectStrict : copyObjectLoose,
+        regExp: copyRegExp,
+        set: strict ? copySetStrict : copySetLoose
+      };
+      const methods = methodsOverride ? Object.assign(defaultMethods, methodsOverride) : defaultMethods;
+      const copiers = getTagSpecificCopiers(methods);
+      const createCache = createCacheOverride || createDefaultCache;
+      if (!copiers.Object || !copiers.Array) {
+        throw new Error("An object and array copier must be provided.");
+      }
+      return { createCache, copiers, methods, strict: Boolean(strict) };
+    }
+    function getTagSpecificCopiers(methods) {
+      return {
+        Arguments: methods.object,
+        Array: methods.array,
+        ArrayBuffer: methods.arrayBuffer,
+        AsyncGenerator: methods.asyncGenerator,
+        Blob: methods.blob,
+        Boolean: copyPrimitiveWrapper,
+        DataView: methods.dataView,
+        Date: methods.date,
+        Error: methods.error,
+        Float32Array: methods.arrayBuffer,
+        Float64Array: methods.arrayBuffer,
+        Generator: methods.generator,
+        Int8Array: methods.arrayBuffer,
+        Int16Array: methods.arrayBuffer,
+        Int32Array: methods.arrayBuffer,
+        Map: methods.map,
+        Number: copyPrimitiveWrapper,
+        Object: methods.object,
+        Promise: copySelf,
+        RegExp: methods.regExp,
+        Set: methods.set,
+        String: copyPrimitiveWrapper,
+        WeakMap: copySelf,
+        WeakSet: copySelf,
+        Uint8Array: methods.arrayBuffer,
+        Uint8ClampedArray: methods.arrayBuffer,
+        Uint16Array: methods.arrayBuffer,
+        Uint32Array: methods.arrayBuffer,
+        Uint64Array: methods.arrayBuffer
+      };
+    }
+    function createCopier(options = {}) {
+      const { createCache, copiers } = getOptions(options);
+      const { Array: copyArray, Object: copyObject } = copiers;
+      function copier(value, state) {
+        state.prototype = state.Constructor = void 0;
+        if (!value || typeof value !== "object") {
+          return value;
+        }
+        if (state.cache.has(value)) {
+          return state.cache.get(value);
+        }
+        state.prototype = Object.getPrototypeOf(value);
+        state.Constructor = state.prototype && state.prototype.constructor;
+        if (!state.Constructor || state.Constructor === Object) {
+          return copyObject(value, state);
+        }
+        if (Array.isArray(value)) {
+          return copyArray(value, state);
+        }
+        const tagSpecificCopier = copiers[getTag(value)];
+        if (tagSpecificCopier) {
+          return tagSpecificCopier(value, state);
+        }
+        return typeof value.then === "function" ? value : copyObject(value, state);
+      }
+      return function copy2(value) {
+        return copier(value, {
+          Constructor: void 0,
+          cache: createCache(),
+          copier,
+          prototype: void 0
+        });
+      };
+    }
+    var copyStrict = createCopier({ strict: true });
+    var copy = createCopier();
+    exports2.copy = copy;
+    exports2.copyStrict = copyStrict;
+    exports2.createCopier = createCopier;
+  }
+});
+
+// node_modules/pino-pretty/lib/utils/filter-log.js
+var require_filter_log = __commonJS({
+  "node_modules/pino-pretty/lib/utils/filter-log.js"(exports2, module2) {
+    "use strict";
+    module2.exports = filterLog;
+    var { createCopier } = require_cjs2();
+    var fastCopy = createCopier({});
+    var deleteLogProperty = require_delete_log_property();
+    function filterLog({ log: log3, context: context2 }) {
+      const { ignoreKeys, includeKeys } = context2;
+      const logCopy = fastCopy(log3);
+      if (includeKeys) {
+        const logIncluded = {};
+        includeKeys.forEach((key) => {
+          logIncluded[key] = logCopy[key];
+        });
+        return logIncluded;
+      }
+      ignoreKeys.forEach((ignoreKey) => {
+        deleteLogProperty(logCopy, ignoreKey);
+      });
+      return logCopy;
+    }
+  }
+});
+
+// node_modules/dateformat/lib/dateformat.js
+var require_dateformat = __commonJS({
+  "node_modules/dateformat/lib/dateformat.js"(exports2, module2) {
+    "use strict";
+    function _typeof(obj) {
+      "@babel/helpers - typeof";
+      if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+        _typeof = function _typeof2(obj2) {
+          return typeof obj2;
+        };
+      } else {
+        _typeof = function _typeof2(obj2) {
+          return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+        };
+      }
+      return _typeof(obj);
+    }
+    (function(global2) {
+      var _arguments = arguments;
+      var dateFormat = /* @__PURE__ */ (function() {
+        var token = /d{1,4}|D{3,4}|m{1,4}|yy(?:yy)?|([HhMsTt])\1?|W{1,2}|[LlopSZN]|"[^"]*"|'[^']*'/g;
+        var timezone = /\b(?:[PMCEA][SDP]T|(?:Pacific|Mountain|Central|Eastern|Atlantic) (?:Standard|Daylight|Prevailing) Time|(?:GMT|UTC)(?:[-+]\d{4})?)\b/g;
+        var timezoneClip = /[^-+\dA-Z]/g;
+        return function(date5, mask, utc, gmt) {
+          if (_arguments.length === 1 && kindOf(date5) === "string" && !/\d/.test(date5)) {
+            mask = date5;
+            date5 = void 0;
+          }
+          date5 = date5 || date5 === 0 ? date5 : /* @__PURE__ */ new Date();
+          if (!(date5 instanceof Date)) {
+            date5 = new Date(date5);
+          }
+          if (isNaN(date5)) {
+            throw TypeError("Invalid date");
+          }
+          mask = String(dateFormat.masks[mask] || mask || dateFormat.masks["default"]);
+          var maskSlice = mask.slice(0, 4);
+          if (maskSlice === "UTC:" || maskSlice === "GMT:") {
+            mask = mask.slice(4);
+            utc = true;
+            if (maskSlice === "GMT:") {
+              gmt = true;
+            }
+          }
+          var _ = function _2() {
+            return utc ? "getUTC" : "get";
+          };
+          var _d = function d() {
+            return date5[_() + "Date"]();
+          };
+          var D = function D2() {
+            return date5[_() + "Day"]();
+          };
+          var _m = function m2() {
+            return date5[_() + "Month"]();
+          };
+          var y = function y2() {
+            return date5[_() + "FullYear"]();
+          };
+          var _H = function H() {
+            return date5[_() + "Hours"]();
+          };
+          var _M = function M() {
+            return date5[_() + "Minutes"]();
+          };
+          var _s = function s2() {
+            return date5[_() + "Seconds"]();
+          };
+          var _L = function L() {
+            return date5[_() + "Milliseconds"]();
+          };
+          var _o = function o() {
+            return utc ? 0 : date5.getTimezoneOffset();
+          };
+          var _W = function W() {
+            return getWeek(date5);
+          };
+          var _N = function N() {
+            return getDayOfWeek(date5);
+          };
+          var flags = { d: function d() {
+            return _d();
+          }, dd: function dd() {
+            return pad(_d());
+          }, ddd: function ddd() {
+            return dateFormat.i18n.dayNames[D()];
+          }, DDD: function DDD() {
+            return getDayName({ y: y(), m: _m(), d: _d(), _: _(), dayName: dateFormat.i18n.dayNames[D()], short: true });
+          }, dddd: function dddd() {
+            return dateFormat.i18n.dayNames[D() + 7];
+          }, DDDD: function DDDD() {
+            return getDayName({ y: y(), m: _m(), d: _d(), _: _(), dayName: dateFormat.i18n.dayNames[D() + 7] });
+          }, m: function m2() {
+            return _m() + 1;
+          }, mm: function mm() {
+            return pad(_m() + 1);
+          }, mmm: function mmm() {
+            return dateFormat.i18n.monthNames[_m()];
+          }, mmmm: function mmmm() {
+            return dateFormat.i18n.monthNames[_m() + 12];
+          }, yy: function yy() {
+            return String(y()).slice(2);
+          }, yyyy: function yyyy() {
+            return pad(y(), 4);
+          }, h: function h2() {
+            return _H() % 12 || 12;
+          }, hh: function hh() {
+            return pad(_H() % 12 || 12);
+          }, H: function H() {
+            return _H();
+          }, HH: function HH() {
+            return pad(_H());
+          }, M: function M() {
+            return _M();
+          }, MM: function MM() {
+            return pad(_M());
+          }, s: function s2() {
+            return _s();
+          }, ss: function ss() {
+            return pad(_s());
+          }, l: function l() {
+            return pad(_L(), 3);
+          }, L: function L() {
+            return pad(Math.floor(_L() / 10));
+          }, t: function t2() {
+            return _H() < 12 ? dateFormat.i18n.timeNames[0] : dateFormat.i18n.timeNames[1];
+          }, tt: function tt() {
+            return _H() < 12 ? dateFormat.i18n.timeNames[2] : dateFormat.i18n.timeNames[3];
+          }, T: function T() {
+            return _H() < 12 ? dateFormat.i18n.timeNames[4] : dateFormat.i18n.timeNames[5];
+          }, TT: function TT() {
+            return _H() < 12 ? dateFormat.i18n.timeNames[6] : dateFormat.i18n.timeNames[7];
+          }, Z: function Z2() {
+            return gmt ? "GMT" : utc ? "UTC" : (String(date5).match(timezone) || [""]).pop().replace(timezoneClip, "").replace(/GMT\+0000/g, "UTC");
+          }, o: function o() {
+            return (_o() > 0 ? "-" : "+") + pad(Math.floor(Math.abs(_o()) / 60) * 100 + Math.abs(_o()) % 60, 4);
+          }, p: function p() {
+            return (_o() > 0 ? "-" : "+") + pad(Math.floor(Math.abs(_o()) / 60), 2) + ":" + pad(Math.floor(Math.abs(_o()) % 60), 2);
+          }, S: function S2() {
+            return ["th", "st", "nd", "rd"][_d() % 10 > 3 ? 0 : (_d() % 100 - _d() % 10 != 10) * _d() % 10];
+          }, W: function W() {
+            return _W();
+          }, WW: function WW() {
+            return pad(_W());
+          }, N: function N() {
+            return _N();
+          } };
+          return mask.replace(token, function(match) {
+            if (match in flags) {
+              return flags[match]();
+            }
+            return match.slice(1, match.length - 1);
+          });
+        };
+      })();
+      dateFormat.masks = { default: "ddd mmm dd yyyy HH:MM:ss", shortDate: "m/d/yy", paddedShortDate: "mm/dd/yyyy", mediumDate: "mmm d, yyyy", longDate: "mmmm d, yyyy", fullDate: "dddd, mmmm d, yyyy", shortTime: "h:MM TT", mediumTime: "h:MM:ss TT", longTime: "h:MM:ss TT Z", isoDate: "yyyy-mm-dd", isoTime: "HH:MM:ss", isoDateTime: "yyyy-mm-dd'T'HH:MM:sso", isoUtcDateTime: "UTC:yyyy-mm-dd'T'HH:MM:ss'Z'", expiresHeaderFormat: "ddd, dd mmm yyyy HH:MM:ss Z" };
+      dateFormat.i18n = { dayNames: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"], monthNames: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec", "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"], timeNames: ["a", "p", "am", "pm", "A", "P", "AM", "PM"] };
+      var pad = function pad2(val, len) {
+        val = String(val);
+        len = len || 2;
+        while (val.length < len) {
+          val = "0" + val;
+        }
+        return val;
+      };
+      var getDayName = function getDayName2(_ref) {
+        var y = _ref.y, m2 = _ref.m, d = _ref.d, _ = _ref._, dayName = _ref.dayName, _ref$short = _ref["short"], _short = _ref$short === void 0 ? false : _ref$short;
+        var today = /* @__PURE__ */ new Date();
+        var yesterday = /* @__PURE__ */ new Date();
+        yesterday.setDate(yesterday[_ + "Date"]() - 1);
+        var tomorrow = /* @__PURE__ */ new Date();
+        tomorrow.setDate(tomorrow[_ + "Date"]() + 1);
+        var today_d = function today_d2() {
+          return today[_ + "Date"]();
+        };
+        var today_m = function today_m2() {
+          return today[_ + "Month"]();
+        };
+        var today_y = function today_y2() {
+          return today[_ + "FullYear"]();
+        };
+        var yesterday_d = function yesterday_d2() {
+          return yesterday[_ + "Date"]();
+        };
+        var yesterday_m = function yesterday_m2() {
+          return yesterday[_ + "Month"]();
+        };
+        var yesterday_y = function yesterday_y2() {
+          return yesterday[_ + "FullYear"]();
+        };
+        var tomorrow_d = function tomorrow_d2() {
+          return tomorrow[_ + "Date"]();
+        };
+        var tomorrow_m = function tomorrow_m2() {
+          return tomorrow[_ + "Month"]();
+        };
+        var tomorrow_y = function tomorrow_y2() {
+          return tomorrow[_ + "FullYear"]();
+        };
+        if (today_y() === y && today_m() === m2 && today_d() === d) {
+          return _short ? "Tdy" : "Today";
+        } else if (yesterday_y() === y && yesterday_m() === m2 && yesterday_d() === d) {
+          return _short ? "Ysd" : "Yesterday";
+        } else if (tomorrow_y() === y && tomorrow_m() === m2 && tomorrow_d() === d) {
+          return _short ? "Tmw" : "Tomorrow";
+        }
+        return dayName;
+      };
+      var getWeek = function getWeek2(date5) {
+        var targetThursday = new Date(date5.getFullYear(), date5.getMonth(), date5.getDate());
+        targetThursday.setDate(targetThursday.getDate() - (targetThursday.getDay() + 6) % 7 + 3);
+        var firstThursday = new Date(targetThursday.getFullYear(), 0, 4);
+        firstThursday.setDate(firstThursday.getDate() - (firstThursday.getDay() + 6) % 7 + 3);
+        var ds = targetThursday.getTimezoneOffset() - firstThursday.getTimezoneOffset();
+        targetThursday.setHours(targetThursday.getHours() - ds);
+        var weekDiff = (targetThursday - firstThursday) / (864e5 * 7);
+        return 1 + Math.floor(weekDiff);
+      };
+      var getDayOfWeek = function getDayOfWeek2(date5) {
+        var dow = date5.getDay();
+        if (dow === 0) {
+          dow = 7;
+        }
+        return dow;
+      };
+      var kindOf = function kindOf2(val) {
+        if (val === null) {
+          return "null";
+        }
+        if (val === void 0) {
+          return "undefined";
+        }
+        if (_typeof(val) !== "object") {
+          return _typeof(val);
+        }
+        if (Array.isArray(val)) {
+          return "array";
+        }
+        return {}.toString.call(val).slice(8, -1).toLowerCase();
+      };
+      if (typeof define === "function" && define.amd) {
+        define(function() {
+          return dateFormat;
+        });
+      } else if ((typeof exports2 === "undefined" ? "undefined" : _typeof(exports2)) === "object") {
+        module2.exports = dateFormat;
+      } else {
+        global2.dateFormat = dateFormat;
+      }
+    })(void 0);
+  }
+});
+
+// node_modules/pino-pretty/lib/utils/format-time.js
+var require_format_time = __commonJS({
+  "node_modules/pino-pretty/lib/utils/format-time.js"(exports2, module2) {
+    "use strict";
+    module2.exports = formatTime;
+    var {
+      DATE_FORMAT,
+      DATE_FORMAT_SIMPLE
+    } = require_constants11();
+    var dateformat = require_dateformat();
+    var createDate = require_create_date();
+    var isValidDate = require_is_valid_date();
+    function formatTime(epoch, translateTime = false) {
+      if (translateTime === false) {
+        return epoch;
+      }
+      const instant = createDate(epoch);
+      if (!isValidDate(instant)) {
+        return epoch;
+      }
+      if (translateTime === true) {
+        return dateformat(instant, DATE_FORMAT_SIMPLE);
+      }
+      const upperFormat = translateTime.toUpperCase();
+      if (upperFormat === "SYS:STANDARD") {
+        return dateformat(instant, DATE_FORMAT);
+      }
+      const prefix = upperFormat.substr(0, 4);
+      if (prefix === "SYS:" || prefix === "UTC:") {
+        if (prefix === "UTC:") {
+          return dateformat(instant, translateTime);
+        }
+        return dateformat(instant, translateTime.slice(4));
+      }
+      return dateformat(instant, `UTC:${translateTime}`);
+    }
+  }
+});
+
+// node_modules/pino-pretty/lib/utils/handle-custom-levels-names-opts.js
+var require_handle_custom_levels_names_opts = __commonJS({
+  "node_modules/pino-pretty/lib/utils/handle-custom-levels-names-opts.js"(exports2, module2) {
+    "use strict";
+    module2.exports = handleCustomLevelsNamesOpts;
+    function handleCustomLevelsNamesOpts(cLevels) {
+      if (!cLevels) return {};
+      if (typeof cLevels === "string") {
+        return cLevels.split(",").reduce((agg, value, idx) => {
+          const [levelName, levelNum = idx] = value.split(":");
+          agg[levelName.toLowerCase()] = levelNum;
+          return agg;
+        }, {});
+      } else if (Object.prototype.toString.call(cLevels) === "[object Object]") {
+        return Object.keys(cLevels).reduce((agg, levelName) => {
+          agg[levelName.toLowerCase()] = cLevels[levelName];
+          return agg;
+        }, {});
+      } else {
+        return {};
+      }
+    }
+  }
+});
+
+// node_modules/pino-pretty/lib/utils/handle-custom-levels-opts.js
+var require_handle_custom_levels_opts = __commonJS({
+  "node_modules/pino-pretty/lib/utils/handle-custom-levels-opts.js"(exports2, module2) {
+    "use strict";
+    module2.exports = handleCustomLevelsOpts;
+    function handleCustomLevelsOpts(cLevels) {
+      if (!cLevels) return {};
+      if (typeof cLevels === "string") {
+        return cLevels.split(",").reduce(
+          (agg, value, idx) => {
+            const [levelName, levelNum = idx] = value.split(":");
+            agg[levelNum] = levelName.toUpperCase();
+            return agg;
+          },
+          { default: "USERLVL" }
+        );
+      } else if (Object.prototype.toString.call(cLevels) === "[object Object]") {
+        return Object.keys(cLevels).reduce((agg, levelName) => {
+          agg[cLevels[levelName]] = levelName.toUpperCase();
+          return agg;
+        }, { default: "USERLVL" });
+      } else {
+        return {};
+      }
+    }
+  }
+});
+
+// node_modules/pino-pretty/lib/utils/interpret-conditionals.js
+var require_interpret_conditionals = __commonJS({
+  "node_modules/pino-pretty/lib/utils/interpret-conditionals.js"(exports2, module2) {
+    "use strict";
+    module2.exports = interpretConditionals;
+    var getPropertyValue = require_get_property_value();
+    function interpretConditionals(messageFormat, log3) {
+      messageFormat = messageFormat.replace(/{if (.*?)}(.*?){end}/g, replacer);
+      messageFormat = messageFormat.replace(/{if (.*?)}/g, "");
+      messageFormat = messageFormat.replace(/{end}/g, "");
+      return messageFormat.replace(/\s+/g, " ").trim();
+      function replacer(_, key, value) {
+        const propertyValue = getPropertyValue(log3, key);
+        if (propertyValue && value.includes(key)) {
+          return value.replace(new RegExp("{" + key + "}", "g"), propertyValue);
+        } else {
+          return "";
+        }
+      }
+    }
+  }
+});
+
+// node_modules/pino-pretty/lib/utils/is-object.js
+var require_is_object = __commonJS({
+  "node_modules/pino-pretty/lib/utils/is-object.js"(exports2, module2) {
+    "use strict";
+    module2.exports = isObject2;
+    function isObject2(input) {
+      return Object.prototype.toString.apply(input) === "[object Object]";
+    }
+  }
+});
+
+// node_modules/pino-pretty/lib/utils/join-lines-with-indentation.js
+var require_join_lines_with_indentation = __commonJS({
+  "node_modules/pino-pretty/lib/utils/join-lines-with-indentation.js"(exports2, module2) {
+    "use strict";
+    module2.exports = joinLinesWithIndentation;
+    function joinLinesWithIndentation({ input, ident = "    ", eol = "\n" }) {
+      const lines = input.split(/\r?\n/);
+      for (let i2 = 1; i2 < lines.length; i2 += 1) {
+        lines[i2] = ident + lines[i2];
+      }
+      return lines.join(eol);
+    }
+  }
+});
+
+// node_modules/pino-pretty/lib/utils/parse-factory-options.js
+var require_parse_factory_options = __commonJS({
+  "node_modules/pino-pretty/lib/utils/parse-factory-options.js"(exports2, module2) {
+    "use strict";
+    module2.exports = parseFactoryOptions;
+    var {
+      LEVEL_NAMES
+    } = require_constants11();
+    var colors = require_colors();
+    var handleCustomLevelsOpts = require_handle_custom_levels_opts();
+    var handleCustomLevelsNamesOpts = require_handle_custom_levels_names_opts();
+    var handleLevelLabelData = require_get_level_label_data();
+    function parseFactoryOptions(options) {
+      const EOL = options.crlf ? "\r\n" : "\n";
+      const IDENT = "    ";
+      const {
+        customPrettifiers,
+        errorLikeObjectKeys,
+        hideObject,
+        levelFirst,
+        levelKey,
+        levelLabel,
+        messageFormat,
+        messageKey,
+        minimumLevel,
+        singleLine,
+        timestampKey,
+        translateTime
+      } = options;
+      const errorProps = options.errorProps.split(",");
+      const useOnlyCustomProps = typeof options.useOnlyCustomProps === "boolean" ? options.useOnlyCustomProps : options.useOnlyCustomProps === "true";
+      const customLevels = handleCustomLevelsOpts(options.customLevels);
+      const customLevelNames = handleCustomLevelsNamesOpts(options.customLevels);
+      const getLevelLabelData = handleLevelLabelData(useOnlyCustomProps, customLevels, customLevelNames);
+      let customColors;
+      if (options.customColors) {
+        if (typeof options.customColors === "string") {
+          customColors = options.customColors.split(",").reduce((agg, value) => {
+            const [level, color] = value.split(":");
+            const condition = useOnlyCustomProps ? options.customLevels : customLevelNames[level] !== void 0;
+            const levelNum = condition ? customLevelNames[level] : LEVEL_NAMES[level];
+            const colorIdx = levelNum !== void 0 ? levelNum : level;
+            agg.push([colorIdx, color]);
+            return agg;
+          }, []);
+        } else if (typeof options.customColors === "object") {
+          customColors = Object.keys(options.customColors).reduce((agg, value) => {
+            const [level, color] = [value, options.customColors[value]];
+            const condition = useOnlyCustomProps ? options.customLevels : customLevelNames[level] !== void 0;
+            const levelNum = condition ? customLevelNames[level] : LEVEL_NAMES[level];
+            const colorIdx = levelNum !== void 0 ? levelNum : level;
+            agg.push([colorIdx, color]);
+            return agg;
+          }, []);
+        } else {
+          throw new Error("options.customColors must be of type string or object.");
+        }
+      }
+      const customProperties = { customLevels, customLevelNames };
+      if (useOnlyCustomProps === true && !options.customLevels) {
+        customProperties.customLevels = void 0;
+        customProperties.customLevelNames = void 0;
+      }
+      const includeKeys = options.include !== void 0 ? new Set(options.include.split(",")) : void 0;
+      const ignoreKeys = !includeKeys && options.ignore ? new Set(options.ignore.split(",")) : void 0;
+      const colorizer = colors(options.colorize, customColors, useOnlyCustomProps);
+      const objectColorizer = options.colorizeObjects ? colorizer : colors(false, [], false);
+      return {
+        EOL,
+        IDENT,
+        colorizer,
+        customColors,
+        customLevelNames,
+        customLevels,
+        customPrettifiers,
+        customProperties,
+        errorLikeObjectKeys,
+        errorProps,
+        getLevelLabelData,
+        hideObject,
+        ignoreKeys,
+        includeKeys,
+        levelFirst,
+        levelKey,
+        levelLabel,
+        messageFormat,
+        messageKey,
+        minimumLevel,
+        objectColorizer,
+        singleLine,
+        timestampKey,
+        translateTime,
+        useOnlyCustomProps
+      };
+    }
+  }
+});
+
+// node_modules/fast-safe-stringify/index.js
+var require_fast_safe_stringify = __commonJS({
+  "node_modules/fast-safe-stringify/index.js"(exports2, module2) {
+    module2.exports = stringify;
+    stringify.default = stringify;
+    stringify.stable = deterministicStringify;
+    stringify.stableStringify = deterministicStringify;
+    var LIMIT_REPLACE_NODE = "[...]";
+    var CIRCULAR_REPLACE_NODE = "[Circular]";
+    var arr = [];
+    var replacerStack = [];
+    function defaultOptions2() {
+      return {
+        depthLimit: Number.MAX_SAFE_INTEGER,
+        edgesLimit: Number.MAX_SAFE_INTEGER
+      };
+    }
+    function stringify(obj, replacer, spacer, options) {
+      if (typeof options === "undefined") {
+        options = defaultOptions2();
+      }
+      decirc(obj, "", 0, [], void 0, 0, options);
+      var res;
+      try {
+        if (replacerStack.length === 0) {
+          res = JSON.stringify(obj, replacer, spacer);
+        } else {
+          res = JSON.stringify(obj, replaceGetterValues(replacer), spacer);
+        }
+      } catch (_) {
+        return JSON.stringify("[unable to serialize, circular reference is too complex to analyze]");
+      } finally {
+        while (arr.length !== 0) {
+          var part = arr.pop();
+          if (part.length === 4) {
+            Object.defineProperty(part[0], part[1], part[3]);
+          } else {
+            part[0][part[1]] = part[2];
+          }
+        }
+      }
+      return res;
+    }
+    function setReplace(replace, val, k, parent) {
+      var propertyDescriptor = Object.getOwnPropertyDescriptor(parent, k);
+      if (propertyDescriptor.get !== void 0) {
+        if (propertyDescriptor.configurable) {
+          Object.defineProperty(parent, k, { value: replace });
+          arr.push([parent, k, val, propertyDescriptor]);
+        } else {
+          replacerStack.push([val, k, replace]);
+        }
+      } else {
+        parent[k] = replace;
+        arr.push([parent, k, val]);
+      }
+    }
+    function decirc(val, k, edgeIndex, stack, parent, depth, options) {
+      depth += 1;
+      var i2;
+      if (typeof val === "object" && val !== null) {
+        for (i2 = 0; i2 < stack.length; i2++) {
+          if (stack[i2] === val) {
+            setReplace(CIRCULAR_REPLACE_NODE, val, k, parent);
+            return;
+          }
+        }
+        if (typeof options.depthLimit !== "undefined" && depth > options.depthLimit) {
+          setReplace(LIMIT_REPLACE_NODE, val, k, parent);
+          return;
+        }
+        if (typeof options.edgesLimit !== "undefined" && edgeIndex + 1 > options.edgesLimit) {
+          setReplace(LIMIT_REPLACE_NODE, val, k, parent);
+          return;
+        }
+        stack.push(val);
+        if (Array.isArray(val)) {
+          for (i2 = 0; i2 < val.length; i2++) {
+            decirc(val[i2], i2, i2, stack, val, depth, options);
+          }
+        } else {
+          var keys = Object.keys(val);
+          for (i2 = 0; i2 < keys.length; i2++) {
+            var key = keys[i2];
+            decirc(val[key], key, i2, stack, val, depth, options);
+          }
+        }
+        stack.pop();
+      }
+    }
+    function compareFunction(a, b) {
+      if (a < b) {
+        return -1;
+      }
+      if (a > b) {
+        return 1;
+      }
+      return 0;
+    }
+    function deterministicStringify(obj, replacer, spacer, options) {
+      if (typeof options === "undefined") {
+        options = defaultOptions2();
+      }
+      var tmp = deterministicDecirc(obj, "", 0, [], void 0, 0, options) || obj;
+      var res;
+      try {
+        if (replacerStack.length === 0) {
+          res = JSON.stringify(tmp, replacer, spacer);
+        } else {
+          res = JSON.stringify(tmp, replaceGetterValues(replacer), spacer);
+        }
+      } catch (_) {
+        return JSON.stringify("[unable to serialize, circular reference is too complex to analyze]");
+      } finally {
+        while (arr.length !== 0) {
+          var part = arr.pop();
+          if (part.length === 4) {
+            Object.defineProperty(part[0], part[1], part[3]);
+          } else {
+            part[0][part[1]] = part[2];
+          }
+        }
+      }
+      return res;
+    }
+    function deterministicDecirc(val, k, edgeIndex, stack, parent, depth, options) {
+      depth += 1;
+      var i2;
+      if (typeof val === "object" && val !== null) {
+        for (i2 = 0; i2 < stack.length; i2++) {
+          if (stack[i2] === val) {
+            setReplace(CIRCULAR_REPLACE_NODE, val, k, parent);
+            return;
+          }
+        }
+        try {
+          if (typeof val.toJSON === "function") {
+            return;
+          }
+        } catch (_) {
+          return;
+        }
+        if (typeof options.depthLimit !== "undefined" && depth > options.depthLimit) {
+          setReplace(LIMIT_REPLACE_NODE, val, k, parent);
+          return;
+        }
+        if (typeof options.edgesLimit !== "undefined" && edgeIndex + 1 > options.edgesLimit) {
+          setReplace(LIMIT_REPLACE_NODE, val, k, parent);
+          return;
+        }
+        stack.push(val);
+        if (Array.isArray(val)) {
+          for (i2 = 0; i2 < val.length; i2++) {
+            deterministicDecirc(val[i2], i2, i2, stack, val, depth, options);
+          }
+        } else {
+          var tmp = {};
+          var keys = Object.keys(val).sort(compareFunction);
+          for (i2 = 0; i2 < keys.length; i2++) {
+            var key = keys[i2];
+            deterministicDecirc(val[key], key, i2, stack, val, depth, options);
+            tmp[key] = val[key];
+          }
+          if (typeof parent !== "undefined") {
+            arr.push([parent, k, val]);
+            parent[k] = tmp;
+          } else {
+            return tmp;
+          }
+        }
+        stack.pop();
+      }
+    }
+    function replaceGetterValues(replacer) {
+      replacer = typeof replacer !== "undefined" ? replacer : function(k, v) {
+        return v;
+      };
+      return function(key, val) {
+        if (replacerStack.length > 0) {
+          for (var i2 = 0; i2 < replacerStack.length; i2++) {
+            var part = replacerStack[i2];
+            if (part[1] === key && part[0] === val) {
+              val = part[2];
+              replacerStack.splice(i2, 1);
+              break;
+            }
+          }
+        }
+        return replacer.call(this, key, val);
+      };
+    }
+  }
+});
+
+// node_modules/pino-pretty/lib/utils/prettify-error.js
+var require_prettify_error = __commonJS({
+  "node_modules/pino-pretty/lib/utils/prettify-error.js"(exports2, module2) {
+    "use strict";
+    module2.exports = prettifyError2;
+    var joinLinesWithIndentation = require_join_lines_with_indentation();
+    function prettifyError2({ keyName, lines, eol, ident }) {
+      let result = "";
+      const joinedLines = joinLinesWithIndentation({ input: lines, ident, eol });
+      const splitLines = `${ident}${keyName}: ${joinedLines}${eol}`.split(eol);
+      for (let j = 0; j < splitLines.length; j += 1) {
+        if (j !== 0) result += eol;
+        const line = splitLines[j];
+        if (/^\s*"stack"/.test(line)) {
+          const matches2 = /^(\s*"stack":)\s*(".*"),?$/.exec(line);
+          if (matches2 && matches2.length === 3) {
+            const indentSize = /^\s*/.exec(line)[0].length + 4;
+            const indentation = " ".repeat(indentSize);
+            const stackMessage = matches2[2];
+            result += matches2[1] + eol + indentation + JSON.parse(stackMessage).replace(/\n/g, eol + indentation);
+          } else {
+            result += line;
+          }
+        } else {
+          result += line;
+        }
+      }
+      return result;
+    }
+  }
+});
+
+// node_modules/pino-pretty/lib/utils/prettify-object.js
+var require_prettify_object = __commonJS({
+  "node_modules/pino-pretty/lib/utils/prettify-object.js"(exports2, module2) {
+    "use strict";
+    module2.exports = prettifyObject;
+    var {
+      LOGGER_KEYS
+    } = require_constants11();
+    var stringifySafe = require_fast_safe_stringify();
+    var joinLinesWithIndentation = require_join_lines_with_indentation();
+    var prettifyError2 = require_prettify_error();
+    function prettifyObject({
+      log: log3,
+      excludeLoggerKeys = true,
+      skipKeys = [],
+      context: context2
+    }) {
+      const {
+        EOL: eol,
+        IDENT: ident,
+        customPrettifiers,
+        errorLikeObjectKeys: errorLikeKeys,
+        objectColorizer,
+        singleLine,
+        colorizer
+      } = context2;
+      const keysToIgnore = [].concat(skipKeys);
+      if (excludeLoggerKeys === true) Array.prototype.push.apply(keysToIgnore, LOGGER_KEYS);
+      let result = "";
+      const { plain, errors } = Object.entries(log3).reduce(({ plain: plain2, errors: errors2 }, [k, v]) => {
+        if (keysToIgnore.includes(k) === false) {
+          const pretty = typeof customPrettifiers[k] === "function" ? customPrettifiers[k](v, k, log3, { colors: colorizer.colors }) : v;
+          if (errorLikeKeys.includes(k)) {
+            errors2[k] = pretty;
+          } else {
+            plain2[k] = pretty;
+          }
+        }
+        return { plain: plain2, errors: errors2 };
+      }, { plain: {}, errors: {} });
+      if (singleLine) {
+        if (Object.keys(plain).length > 0) {
+          result += objectColorizer.greyMessage(stringifySafe(plain));
+        }
+        result += eol;
+        result = result.replace(/\\\\/gi, "\\");
+      } else {
+        Object.entries(plain).forEach(([keyName, keyValue]) => {
+          let lines = typeof customPrettifiers[keyName] === "function" ? keyValue : stringifySafe(keyValue, null, 2);
+          if (lines === void 0) return;
+          lines = lines.replace(/\\\\/gi, "\\");
+          const joinedLines = joinLinesWithIndentation({ input: lines, ident, eol });
+          result += `${ident}${objectColorizer.property(keyName)}:${joinedLines.startsWith(eol) ? "" : " "}${joinedLines}${eol}`;
+        });
+      }
+      Object.entries(errors).forEach(([keyName, keyValue]) => {
+        const lines = typeof customPrettifiers[keyName] === "function" ? keyValue : stringifySafe(keyValue, null, 2);
+        if (lines === void 0) return;
+        result += prettifyError2({ keyName, lines, eol, ident });
+      });
+      return result;
+    }
+  }
+});
+
+// node_modules/pino-pretty/lib/utils/prettify-error-log.js
+var require_prettify_error_log = __commonJS({
+  "node_modules/pino-pretty/lib/utils/prettify-error-log.js"(exports2, module2) {
+    "use strict";
+    module2.exports = prettifyErrorLog;
+    var {
+      LOGGER_KEYS
+    } = require_constants11();
+    var isObject2 = require_is_object();
+    var joinLinesWithIndentation = require_join_lines_with_indentation();
+    var prettifyObject = require_prettify_object();
+    function prettifyErrorLog({ log: log3, context: context2 }) {
+      const {
+        EOL: eol,
+        IDENT: ident,
+        errorProps: errorProperties,
+        messageKey
+      } = context2;
+      const stack = log3.stack;
+      const joinedLines = joinLinesWithIndentation({ input: stack, ident, eol });
+      let result = `${ident}${joinedLines}${eol}`;
+      if (errorProperties.length > 0) {
+        const excludeProperties = LOGGER_KEYS.concat(messageKey, "type", "stack");
+        let propertiesToPrint;
+        if (errorProperties[0] === "*") {
+          propertiesToPrint = Object.keys(log3).filter((k) => excludeProperties.includes(k) === false);
+        } else {
+          propertiesToPrint = errorProperties.filter((k) => excludeProperties.includes(k) === false);
+        }
+        for (let i2 = 0; i2 < propertiesToPrint.length; i2 += 1) {
+          const key = propertiesToPrint[i2];
+          if (key in log3 === false) continue;
+          if (isObject2(log3[key])) {
+            const prettifiedObject = prettifyObject({
+              log: log3[key],
+              excludeLoggerKeys: false,
+              context: {
+                ...context2,
+                IDENT: ident + ident
+              }
+            });
+            result = `${result}${ident}${key}: {${eol}${prettifiedObject}${ident}}${eol}`;
+            continue;
+          }
+          result = `${result}${ident}${key}: ${log3[key]}${eol}`;
+        }
+      }
+      return result;
+    }
+  }
+});
+
+// node_modules/pino-pretty/lib/utils/prettify-level.js
+var require_prettify_level = __commonJS({
+  "node_modules/pino-pretty/lib/utils/prettify-level.js"(exports2, module2) {
+    "use strict";
+    module2.exports = prettifyLevel;
+    var getPropertyValue = require_get_property_value();
+    function prettifyLevel({ log: log3, context: context2 }) {
+      const {
+        colorizer,
+        customLevels,
+        customLevelNames,
+        levelKey,
+        getLevelLabelData
+      } = context2;
+      const prettifier = context2.customPrettifiers?.level;
+      const output = getPropertyValue(log3, levelKey);
+      if (output === void 0) return void 0;
+      const labelColorized = colorizer(output, { customLevels, customLevelNames });
+      if (prettifier) {
+        const [label] = getLevelLabelData(output);
+        return prettifier(output, levelKey, log3, { label, labelColorized, colors: colorizer.colors });
+      }
+      return labelColorized;
+    }
+  }
+});
+
+// node_modules/pino-pretty/lib/utils/prettify-message.js
+var require_prettify_message = __commonJS({
+  "node_modules/pino-pretty/lib/utils/prettify-message.js"(exports2, module2) {
+    "use strict";
+    module2.exports = prettifyMessage;
+    var {
+      LEVELS
+    } = require_constants11();
+    var getPropertyValue = require_get_property_value();
+    var interpretConditionals = require_interpret_conditionals();
+    function prettifyMessage({ log: log3, context: context2 }) {
+      const {
+        colorizer,
+        customLevels,
+        levelKey,
+        levelLabel,
+        messageFormat,
+        messageKey,
+        useOnlyCustomProps
+      } = context2;
+      if (messageFormat && typeof messageFormat === "string") {
+        const parsedMessageFormat = interpretConditionals(messageFormat, log3);
+        const message = String(parsedMessageFormat).replace(
+          /{([^{}]+)}/g,
+          function(match, p1) {
+            let level;
+            if (p1 === levelLabel && (level = getPropertyValue(log3, levelKey)) !== void 0) {
+              const condition = useOnlyCustomProps ? customLevels === void 0 : customLevels[level] === void 0;
+              return condition ? LEVELS[level] : customLevels[level];
+            }
+            const value = getPropertyValue(log3, p1);
+            return value !== void 0 ? value : "";
+          }
+        );
+        return colorizer.message(message);
+      }
+      if (messageFormat && typeof messageFormat === "function") {
+        const msg = messageFormat(log3, messageKey, levelLabel, { colors: colorizer.colors });
+        return colorizer.message(msg);
+      }
+      if (messageKey in log3 === false) return void 0;
+      if (typeof log3[messageKey] !== "string" && typeof log3[messageKey] !== "number" && typeof log3[messageKey] !== "boolean") return void 0;
+      return colorizer.message(log3[messageKey]);
+    }
+  }
+});
+
+// node_modules/pino-pretty/lib/utils/prettify-metadata.js
+var require_prettify_metadata = __commonJS({
+  "node_modules/pino-pretty/lib/utils/prettify-metadata.js"(exports2, module2) {
+    "use strict";
+    module2.exports = prettifyMetadata;
+    function prettifyMetadata({ log: log3, context: context2 }) {
+      const { customPrettifiers: prettifiers, colorizer } = context2;
+      let line = "";
+      if (log3.name || log3.pid || log3.hostname) {
+        line += "(";
+        if (log3.name) {
+          line += prettifiers.name ? prettifiers.name(log3.name, "name", log3, { colors: colorizer.colors }) : log3.name;
+        }
+        if (log3.pid) {
+          const prettyPid = prettifiers.pid ? prettifiers.pid(log3.pid, "pid", log3, { colors: colorizer.colors }) : log3.pid;
+          if (log3.name && log3.pid) {
+            line += "/" + prettyPid;
+          } else {
+            line += prettyPid;
+          }
+        }
+        if (log3.hostname) {
+          const prettyHostname = prettifiers.hostname ? prettifiers.hostname(log3.hostname, "hostname", log3, { colors: colorizer.colors }) : log3.hostname;
+          line += `${line === "(" ? "on" : " on"} ${prettyHostname}`;
+        }
+        line += ")";
+      }
+      if (log3.caller) {
+        const prettyCaller = prettifiers.caller ? prettifiers.caller(log3.caller, "caller", log3, { colors: colorizer.colors }) : log3.caller;
+        line += `${line === "" ? "" : " "}<${prettyCaller}>`;
+      }
+      if (line === "") {
+        return void 0;
+      } else {
+        return line;
+      }
+    }
+  }
+});
+
+// node_modules/pino-pretty/lib/utils/prettify-time.js
+var require_prettify_time = __commonJS({
+  "node_modules/pino-pretty/lib/utils/prettify-time.js"(exports2, module2) {
+    "use strict";
+    module2.exports = prettifyTime;
+    var formatTime = require_format_time();
+    function prettifyTime({ log: log3, context: context2 }) {
+      const {
+        timestampKey,
+        translateTime: translateFormat
+      } = context2;
+      const prettifier = context2.customPrettifiers?.time;
+      let time3 = null;
+      if (timestampKey in log3) {
+        time3 = log3[timestampKey];
+      } else if ("timestamp" in log3) {
+        time3 = log3.timestamp;
+      }
+      if (time3 === null) return void 0;
+      const output = translateFormat ? formatTime(time3, translateFormat) : time3;
+      return prettifier ? prettifier(output) : `[${output}]`;
+    }
+  }
+});
+
+// node_modules/pino-pretty/lib/utils/index.js
+var require_utils41 = __commonJS({
+  "node_modules/pino-pretty/lib/utils/index.js"(exports2, module2) {
+    "use strict";
+    module2.exports = {
+      buildSafeSonicBoom: require_build_safe_sonic_boom(),
+      createDate: require_create_date(),
+      deleteLogProperty: require_delete_log_property(),
+      filterLog: require_filter_log(),
+      formatTime: require_format_time(),
+      getPropertyValue: require_get_property_value(),
+      handleCustomLevelsNamesOpts: require_handle_custom_levels_names_opts(),
+      handleCustomLevelsOpts: require_handle_custom_levels_opts(),
+      interpretConditionals: require_interpret_conditionals(),
+      isObject: require_is_object(),
+      isValidDate: require_is_valid_date(),
+      joinLinesWithIndentation: require_join_lines_with_indentation(),
+      noop: require_noop(),
+      parseFactoryOptions: require_parse_factory_options(),
+      prettifyErrorLog: require_prettify_error_log(),
+      prettifyError: require_prettify_error(),
+      prettifyLevel: require_prettify_level(),
+      prettifyMessage: require_prettify_message(),
+      prettifyMetadata: require_prettify_metadata(),
+      prettifyObject: require_prettify_object(),
+      prettifyTime: require_prettify_time(),
+      splitPropertyKey: require_split_property_key(),
+      getLevelLabelData: require_get_level_label_data()
+    };
+  }
+});
+
+// node_modules/secure-json-parse/index.js
+var require_secure_json_parse = __commonJS({
+  "node_modules/secure-json-parse/index.js"(exports2, module2) {
+    "use strict";
+    var hasBuffer = typeof Buffer !== "undefined";
+    var suspectProtoRx = /"(?:_|\\u005[Ff])(?:_|\\u005[Ff])(?:p|\\u0070)(?:r|\\u0072)(?:o|\\u006[Ff])(?:t|\\u0074)(?:o|\\u006[Ff])(?:_|\\u005[Ff])(?:_|\\u005[Ff])"\s*:/;
+    var suspectConstructorRx = /"(?:c|\\u0063)(?:o|\\u006[Ff])(?:n|\\u006[Ee])(?:s|\\u0073)(?:t|\\u0074)(?:r|\\u0072)(?:u|\\u0075)(?:c|\\u0063)(?:t|\\u0074)(?:o|\\u006[Ff])(?:r|\\u0072)"\s*:/;
+    function _parse2(text, reviver, options) {
+      if (options == null) {
+        if (reviver !== null && typeof reviver === "object") {
+          options = reviver;
+          reviver = void 0;
+        }
+      }
+      if (hasBuffer && Buffer.isBuffer(text)) {
+        text = text.toString();
+      }
+      if (text && text.charCodeAt(0) === 65279) {
+        text = text.slice(1);
+      }
+      const obj = JSON.parse(text, reviver);
+      if (obj === null || typeof obj !== "object") {
+        return obj;
+      }
+      const protoAction = options && options.protoAction || "error";
+      const constructorAction = options && options.constructorAction || "error";
+      if (protoAction === "ignore" && constructorAction === "ignore") {
+        return obj;
+      }
+      if (protoAction !== "ignore" && constructorAction !== "ignore") {
+        if (suspectProtoRx.test(text) === false && suspectConstructorRx.test(text) === false) {
+          return obj;
+        }
+      } else if (protoAction !== "ignore" && constructorAction === "ignore") {
+        if (suspectProtoRx.test(text) === false) {
+          return obj;
+        }
+      } else {
+        if (suspectConstructorRx.test(text) === false) {
+          return obj;
+        }
+      }
+      return filter(obj, { protoAction, constructorAction, safe: options && options.safe });
+    }
+    function filter(obj, { protoAction = "error", constructorAction = "error", safe } = {}) {
+      let next = [obj];
+      while (next.length) {
+        const nodes = next;
+        next = [];
+        for (const node of nodes) {
+          if (protoAction !== "ignore" && Object.prototype.hasOwnProperty.call(node, "__proto__")) {
+            if (safe === true) {
+              return null;
+            } else if (protoAction === "error") {
+              throw new SyntaxError("Object contains forbidden prototype property");
+            }
+            delete node.__proto__;
+          }
+          if (constructorAction !== "ignore" && Object.prototype.hasOwnProperty.call(node, "constructor") && node.constructor !== null && typeof node.constructor === "object" && Object.prototype.hasOwnProperty.call(node.constructor, "prototype")) {
+            if (safe === true) {
+              return null;
+            } else if (constructorAction === "error") {
+              throw new SyntaxError("Object contains forbidden prototype property");
+            }
+            delete node.constructor;
+          }
+          for (const key in node) {
+            const value = node[key];
+            if (value && typeof value === "object") {
+              next.push(value);
+            }
+          }
+        }
+      }
+      return obj;
+    }
+    function parse3(text, reviver, options) {
+      const { stackTraceLimit } = Error;
+      Error.stackTraceLimit = 0;
+      try {
+        return _parse2(text, reviver, options);
+      } finally {
+        Error.stackTraceLimit = stackTraceLimit;
+      }
+    }
+    function safeParse3(text, reviver) {
+      const { stackTraceLimit } = Error;
+      Error.stackTraceLimit = 0;
+      try {
+        return _parse2(text, reviver, { safe: true });
+      } catch {
+        return void 0;
+      } finally {
+        Error.stackTraceLimit = stackTraceLimit;
+      }
+    }
+    module2.exports = parse3;
+    module2.exports.default = parse3;
+    module2.exports.parse = parse3;
+    module2.exports.safeParse = safeParse3;
+    module2.exports.scan = filter;
+  }
+});
+
+// node_modules/pino-pretty/lib/pretty.js
+var require_pretty = __commonJS({
+  "node_modules/pino-pretty/lib/pretty.js"(exports2, module2) {
+    "use strict";
+    module2.exports = pretty;
+    var sjs = require_secure_json_parse();
+    var isObject2 = require_is_object();
+    var prettifyErrorLog = require_prettify_error_log();
+    var prettifyLevel = require_prettify_level();
+    var prettifyMessage = require_prettify_message();
+    var prettifyMetadata = require_prettify_metadata();
+    var prettifyObject = require_prettify_object();
+    var prettifyTime = require_prettify_time();
+    var filterLog = require_filter_log();
+    var {
+      LEVELS,
+      LEVEL_KEY,
+      LEVEL_NAMES
+    } = require_constants11();
+    var jsonParser = (input) => {
+      try {
+        return { value: sjs.parse(input, { protoAction: "remove" }) };
+      } catch (err) {
+        return { err };
+      }
+    };
+    function pretty(inputData) {
+      let log3;
+      if (!isObject2(inputData)) {
+        const parsed = jsonParser(inputData);
+        if (parsed.err || !isObject2(parsed.value)) {
+          return inputData + this.EOL;
+        }
+        log3 = parsed.value;
+      } else {
+        log3 = inputData;
+      }
+      if (this.minimumLevel) {
+        let condition;
+        if (this.useOnlyCustomProps) {
+          condition = this.customLevels;
+        } else {
+          condition = this.customLevelNames[this.minimumLevel] !== void 0;
+        }
+        let minimum;
+        if (condition) {
+          minimum = this.customLevelNames[this.minimumLevel];
+        } else {
+          minimum = LEVEL_NAMES[this.minimumLevel];
+        }
+        if (!minimum) {
+          minimum = typeof this.minimumLevel === "string" ? LEVEL_NAMES[this.minimumLevel] : LEVEL_NAMES[LEVELS[this.minimumLevel].toLowerCase()];
+        }
+        const level = log3[this.levelKey === void 0 ? LEVEL_KEY : this.levelKey];
+        if (level < minimum) return;
+      }
+      const prettifiedMessage = prettifyMessage({ log: log3, context: this.context });
+      if (this.ignoreKeys || this.includeKeys) {
+        log3 = filterLog({ log: log3, context: this.context });
+      }
+      const prettifiedLevel = prettifyLevel({
+        log: log3,
+        context: {
+          ...this.context,
+          // This is odd. The colorizer ends up relying on the value of
+          // `customProperties` instead of the original `customLevels` and
+          // `customLevelNames`.
+          ...this.context.customProperties
+        }
+      });
+      const prettifiedMetadata = prettifyMetadata({ log: log3, context: this.context });
+      const prettifiedTime = prettifyTime({ log: log3, context: this.context });
+      let line = "";
+      if (this.levelFirst && prettifiedLevel) {
+        line = `${prettifiedLevel}`;
+      }
+      if (prettifiedTime && line === "") {
+        line = `${prettifiedTime}`;
+      } else if (prettifiedTime) {
+        line = `${line} ${prettifiedTime}`;
+      }
+      if (!this.levelFirst && prettifiedLevel) {
+        if (line.length > 0) {
+          line = `${line} ${prettifiedLevel}`;
+        } else {
+          line = prettifiedLevel;
+        }
+      }
+      if (prettifiedMetadata) {
+        if (line.length > 0) {
+          line = `${line} ${prettifiedMetadata}:`;
+        } else {
+          line = prettifiedMetadata;
+        }
+      }
+      if (line.endsWith(":") === false && line !== "") {
+        line += ":";
+      }
+      if (prettifiedMessage !== void 0) {
+        if (line.length > 0) {
+          line = `${line} ${prettifiedMessage}`;
+        } else {
+          line = prettifiedMessage;
+        }
+      }
+      if (line.length > 0 && !this.singleLine) {
+        line += this.EOL;
+      }
+      if (log3.type === "Error" && typeof log3.stack === "string") {
+        const prettifiedErrorLog = prettifyErrorLog({ log: log3, context: this.context });
+        if (this.singleLine) line += this.EOL;
+        line += prettifiedErrorLog;
+      } else if (this.hideObject === false) {
+        const skipKeys = [
+          this.messageKey,
+          this.levelKey,
+          this.timestampKey
+        ].map((key) => key.replaceAll(/\\/g, "")).filter((key) => {
+          return typeof log3[key] === "string" || typeof log3[key] === "number" || typeof log3[key] === "boolean";
+        });
+        const prettifiedObject = prettifyObject({
+          log: log3,
+          skipKeys,
+          context: this.context
+        });
+        if (this.singleLine && !/^\s$/.test(prettifiedObject)) {
+          line += " ";
+        }
+        line += prettifiedObject;
+      }
+      return line;
+    }
+  }
+});
+
+// node_modules/pino-pretty/index.js
+var require_pino_pretty = __commonJS({
+  "node_modules/pino-pretty/index.js"(exports2, module2) {
+    "use strict";
+    var { isColorSupported } = require_colorette();
+    var pump2 = require_pump();
+    var { Transform } = __require("node:stream");
+    var abstractTransport = require_pino_abstract_transport();
+    var colors = require_colors();
+    var {
+      ERROR_LIKE_KEYS,
+      LEVEL_KEY,
+      LEVEL_LABEL,
+      MESSAGE_KEY,
+      TIMESTAMP_KEY
+    } = require_constants11();
+    var {
+      buildSafeSonicBoom,
+      parseFactoryOptions
+    } = require_utils41();
+    var pretty = require_pretty();
+    var defaultOptions2 = {
+      colorize: isColorSupported,
+      colorizeObjects: true,
+      crlf: false,
+      customColors: null,
+      customLevels: null,
+      customPrettifiers: {},
+      errorLikeObjectKeys: ERROR_LIKE_KEYS,
+      errorProps: "",
+      hideObject: false,
+      ignore: "hostname",
+      include: void 0,
+      levelFirst: false,
+      levelKey: LEVEL_KEY,
+      levelLabel: LEVEL_LABEL,
+      messageFormat: null,
+      messageKey: MESSAGE_KEY,
+      minimumLevel: void 0,
+      outputStream: process.stdout,
+      singleLine: false,
+      timestampKey: TIMESTAMP_KEY,
+      translateTime: true,
+      useOnlyCustomProps: true
+    };
+    function prettyFactory(options) {
+      const context2 = parseFactoryOptions(Object.assign({}, defaultOptions2, options));
+      return pretty.bind({ ...context2, context: context2 });
+    }
+    function build(opts = {}) {
+      let pretty2 = prettyFactory(opts);
+      let destination;
+      return abstractTransport(function(source) {
+        source.on("message", function pinoConfigListener(message) {
+          if (!message || message.code !== "PINO_CONFIG") return;
+          Object.assign(opts, {
+            messageKey: message.config.messageKey,
+            errorLikeObjectKeys: Array.from(/* @__PURE__ */ new Set([...opts.errorLikeObjectKeys || ERROR_LIKE_KEYS, message.config.errorKey])),
+            customLevels: message.config.levels.values
+          });
+          pretty2 = prettyFactory(opts);
+          source.off("message", pinoConfigListener);
+        });
+        const stream = new Transform({
+          objectMode: true,
+          autoDestroy: true,
+          transform(chunk, enc, cb) {
+            const line = pretty2(chunk);
+            cb(null, line);
+          }
+        });
+        if (typeof opts.destination === "object" && typeof opts.destination.write === "function") {
+          destination = opts.destination;
+        } else {
+          destination = buildSafeSonicBoom({
+            dest: opts.destination || 1,
+            append: opts.append,
+            mkdir: opts.mkdir,
+            sync: opts.sync
+            // by default sonic will be async
+          });
+        }
+        source.on("unknown", function(line) {
+          destination.write(line + "\n");
+        });
+        pump2(source, stream, destination);
+        return stream;
+      }, {
+        parse: "lines",
+        close(err, cb) {
+          destination.on("close", () => {
+            cb(err);
+          });
+        }
+      });
+    }
+    module2.exports = build;
+    module2.exports.build = build;
+    module2.exports.PinoPretty = build;
+    module2.exports.prettyFactory = prettyFactory;
+    module2.exports.colorizerFactory = colors;
+    module2.exports.isColorSupported = isColorSupported;
+    module2.exports.default = build;
+  }
+});
+
 // lib/observability/logger.ts
-import { createRequire } from "node:module";
 function warnPrettyFallback(error48) {
   if (prettyFallbackWarned) return;
   prettyFallbackWarned = true;
   const reason = error48 instanceof Error ? error48.message : String(error48);
   console.warn(`[fabrica] pretty logging unavailable, falling back to structured logs: ${reason}`);
 }
-function createTransport() {
+function createDestination(destination) {
+  if (destination) return destination;
   if (process.env.LOG_PRETTY !== "1") return void 0;
-  let target;
   try {
-    target = require2.resolve("pino-pretty");
-  } catch (error48) {
-    warnPrettyFallback(error48);
-    return void 0;
-  }
-  try {
-    return import_pino.default.transport({
-      target,
-      options: {
-        colorize: true,
-        translateTime: "SYS:standard",
-        ignore: "pid,hostname"
-      }
+    return (0, import_pino_pretty.default)({
+      colorize: true,
+      translateTime: "SYS:standard",
+      ignore: "pid,hostname"
     });
   } catch (error48) {
     warnPrettyFallback(error48);
@@ -96167,6 +98724,7 @@ function createTransport() {
   }
 }
 function createFabricaLogger(destination) {
+  const resolvedDestination = createDestination(destination);
   return (0, import_pino.default)({
     name: "fabrica",
     level: process.env.LOG_LEVEL ?? "info",
@@ -96215,7 +98773,7 @@ function createFabricaLogger(destination) {
         spanId: spanContext?.spanId
       };
     }
-  }, destination ?? createTransport());
+  }, resolvedDestination);
 }
 function getRootLogger() {
   return rootLogger;
@@ -96223,14 +98781,14 @@ function getRootLogger() {
 function getLogger(bindings) {
   return bindings ? rootLogger.child(bindings) : rootLogger;
 }
-var import_pino, require2, prettyFallbackWarned, rootLogger;
+var import_pino, import_pino_pretty, prettyFallbackWarned, rootLogger;
 var init_logger = __esm({
   "lib/observability/logger.ts"() {
     "use strict";
     import_pino = __toESM(require_pino(), 1);
+    import_pino_pretty = __toESM(require_pino_pretty(), 1);
     init_esm();
     init_context3();
-    require2 = createRequire(import.meta.url);
     prettyFallbackWarned = false;
     rootLogger = createFabricaLogger();
   }
@@ -111347,8 +113905,8 @@ import fsSync from "node:fs";
 import path5 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 function getCurrentVersion() {
-  if ("0.2.16") {
-    return "0.2.16";
+  if ("0.2.17") {
+    return "0.2.17";
   }
   try {
     const pkgPath = path5.join(THIS_DIR, "..", "..", "package.json");
@@ -115811,7 +118369,7 @@ var classify_exports = {};
 __export(classify_exports, {
   classifyStep: () => classifyStep
 });
-import { createRequire as createRequire2 } from "node:module";
+import { createRequire } from "node:module";
 function loadRules() {
   if (cachedRules) return cachedRules;
   cachedRules = _require("../configs/classification-rules.json");
@@ -115864,7 +118422,7 @@ var init_classify = __esm({
     init_runtime_paths();
     init_llm_retry();
     init_zod();
-    _require = createRequire2(import.meta.url);
+    _require = createRequire(import.meta.url);
     LlmResponseSchema = external_exports.object({
       payloads: external_exports.array(external_exports.object({ text: external_exports.string() })).min(1)
     }).passthrough();
@@ -115959,7 +118517,7 @@ var interview_exports = {};
 __export(interview_exports, {
   interviewStep: () => interviewStep
 });
-import { createRequire as createRequire3 } from "node:module";
+import { createRequire as createRequire2 } from "node:module";
 function loadTemplates() {
   if (cachedTemplates) return cachedTemplates;
   cachedTemplates = _require2("../configs/interview-templates.json");
@@ -115969,7 +118527,7 @@ var _require2, cachedTemplates, interviewStep;
 var init_interview = __esm({
   "lib/intake/steps/interview.ts"() {
     "use strict";
-    _require2 = createRequire3(import.meta.url);
+    _require2 = createRequire2(import.meta.url);
     cachedTemplates = null;
     interviewStep = {
       name: "interview",
@@ -137151,8 +139709,8 @@ function validateSpecQuality(input) {
 }
 
 // lib/intake/steps/triage.ts
-import { createRequire as createRequire4 } from "node:module";
-var _require3 = createRequire4(import.meta.url);
+import { createRequire as createRequire3 } from "node:module";
+var _require3 = createRequire3(import.meta.url);
 var cachedMatrix = null;
 function loadMatrix() {
   if (cachedMatrix) return cachedMatrix;