@smplkit/sdk 3.0.103 → 3.0.104

package/dist/index.cjs

@@ -13321,541 +13321,436 @@ var require_caller = __commonJS({
   }
 });
 
-// node_modules/fast-redact/lib/validator.js
-var require_validator = __commonJS({
-  "node_modules/fast-redact/lib/validator.js"(exports2, module2) {
+// node_modules/@pinojs/redact/index.js
+var require_redact = __commonJS({
+  "node_modules/@pinojs/redact/index.js"(exports2, module2) {
     "use strict";
-    module2.exports = validator;
-    function validator(opts = {}) {
-      const {
-        ERR_PATHS_MUST_BE_STRINGS = () => "fast-redact - Paths must be (non-empty) strings",
-        ERR_INVALID_PATH = (s) => `fast-redact \u2013 Invalid path (${s})`
-      } = opts;
-      return function validate({ paths }) {
-        paths.forEach((s) => {
-          if (typeof s !== "string") {
-            throw Error(ERR_PATHS_MUST_BE_STRINGS());
-          }
-          try {
-            if (/〇/.test(s)) throw Error();
-            const expr = (s[0] === "[" ? "" : ".") + s.replace(/^\*/, "\u3007").replace(/\.\*/g, ".\u3007").replace(/\[\*\]/g, "[\u3007]");
-            if (/\n|\r|;/.test(expr)) throw Error();
-            if (/\/\*/.test(expr)) throw Error();
-            Function(`
-            'use strict'
-            const o = new Proxy({}, { get: () => o, set: () => { throw Error() } });
-            const \u3007 = null;
-            o${expr}
-            if ([o${expr}].length !== 1) throw Error()`)();
-          } catch (e) {
-            throw Error(ERR_INVALID_PATH(s));
+    function deepClone(obj) {
+      if (obj === null || typeof obj !== "object") {
+        return obj;
+      }
+      if (obj instanceof Date) {
+        return new Date(obj.getTime());
+      }
+      if (obj instanceof Array) {
+        const cloned = [];
+        for (let i = 0; i < obj.length; i++) {
+          cloned[i] = deepClone(obj[i]);
+        }
+        return cloned;
+      }
+      if (typeof obj === "object") {
+        const cloned = Object.create(Object.getPrototypeOf(obj));
+        for (const key in obj) {
+          if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            cloned[key] = deepClone(obj[key]);
           }
-        });
-      };
-    }
-  }
-});
-
-// node_modules/fast-redact/lib/rx.js
-var require_rx = __commonJS({
-  "node_modules/fast-redact/lib/rx.js"(exports2, module2) {
-    "use strict";
-    module2.exports = /[^.[\]]+|\[((?:.)*?)\]/g;
-  }
-});
-
-// node_modules/fast-redact/lib/parse.js
-var require_parse = __commonJS({
-  "node_modules/fast-redact/lib/parse.js"(exports2, module2) {
-    "use strict";
-    var rx = require_rx();
-    module2.exports = parse2;
-    function parse2({ paths }) {
-      const wildcards = [];
-      var wcLen = 0;
-      const secret = paths.reduce(function(o, strPath, ix) {
-        var path = strPath.match(rx).map((p) => p.replace(/'|"|`/g, ""));
-        const leadingBracket = strPath[0] === "[";
-        path = path.map((p) => {
-          if (p[0] === "[") return p.substr(1, p.length - 2);
-          else return p;
-        });
-        const star = path.indexOf("*");
-        if (star > -1) {
-          const before = path.slice(0, star);
-          const beforeStr = before.join(".");
-          const after = path.slice(star + 1, path.length);
-          const nested = after.length > 0;
-          wcLen++;
-          wildcards.push({
-            before,
-            beforeStr,
-            after,
-            nested
-          });
-        } else {
-          o[strPath] = {
-            path,
-            val: void 0,
-            precensored: false,
-            circle: "",
-            escPath: JSON.stringify(strPath),
-            leadingBracket
-          };
         }
-        return o;
-      }, {});
-      return { wildcards, wcLen, secret };
-    }
-  }
-});
-
-// node_modules/fast-redact/lib/redactor.js
-var require_redactor = __commonJS({
-  "node_modules/fast-redact/lib/redactor.js"(exports2, module2) {
-    "use strict";
-    var rx = require_rx();
-    module2.exports = redactor;
-    function redactor({ secret, serialize, wcLen, strict, isCensorFct, censorFctTakesPath }, state) {
-      const redact = Function("o", `
-    if (typeof o !== 'object' || o == null) {
-      ${strictImpl(strict, serialize)}
-    }
-    const { censor, secret } = this
-    const originalSecret = {}
-    const secretKeys = Object.keys(secret)
-    for (var i = 0; i < secretKeys.length; i++) {
-      originalSecret[secretKeys[i]] = secret[secretKeys[i]]
+        return cloned;
+      }
+      return obj;
     }
-
-    ${redactTmpl(secret, isCensorFct, censorFctTakesPath)}
-    this.compileRestore()
-    ${dynamicRedactTmpl(wcLen > 0, isCensorFct, censorFctTakesPath)}
-    this.secret = originalSecret
-    ${resultTmpl(serialize)}
-  `).bind(state);
-      redact.state = state;
-      if (serialize === false) {
-        redact.restore = (o) => state.restore(o);
-      }
-      return redact;
-    }
-    function redactTmpl(secret, isCensorFct, censorFctTakesPath) {
-      return Object.keys(secret).map((path) => {
-        const { escPath, leadingBracket, path: arrPath } = secret[path];
-        const skip = leadingBracket ? 1 : 0;
-        const delim = leadingBracket ? "" : ".";
-        const hops = [];
-        var match;
-        while ((match = rx.exec(path)) !== null) {
-          const [, ix] = match;
-          const { index, input } = match;
-          if (index > skip) hops.push(input.substring(0, index - (ix ? 0 : 1)));
-        }
-        var existence = hops.map((p) => `o${delim}${p}`).join(" && ");
-        if (existence.length === 0) existence += `o${delim}${path} != null`;
-        else existence += ` && o${delim}${path} != null`;
-        const circularDetection = `
-      switch (true) {
-        ${hops.reverse().map((p) => `
-          case o${delim}${p} === censor:
-            secret[${escPath}].circle = ${JSON.stringify(p)}
-            break
-        `).join("\n")}
-      }
-    `;
-        const censorArgs = censorFctTakesPath ? `val, ${JSON.stringify(arrPath)}` : `val`;
-        return `
-      if (${existence}) {
-        const val = o${delim}${path}
-        if (val === censor) {
-          secret[${escPath}].precensored = true
+    function parsePath(path) {
+      const parts = [];
+      let current = "";
+      let inBrackets = false;
+      let inQuotes = false;
+      let quoteChar = "";
+      for (let i = 0; i < path.length; i++) {
+        const char = path[i];
+        if (!inBrackets && char === ".") {
+          if (current) {
+            parts.push(current);
+            current = "";
+          }
+        } else if (char === "[") {
+          if (current) {
+            parts.push(current);
+            current = "";
+          }
+          inBrackets = true;
+        } else if (char === "]" && inBrackets) {
+          parts.push(current);
+          current = "";
+          inBrackets = false;
+          inQuotes = false;
+        } else if ((char === '"' || char === "'") && inBrackets) {
+          if (!inQuotes) {
+            inQuotes = true;
+            quoteChar = char;
+          } else if (char === quoteChar) {
+            inQuotes = false;
+            quoteChar = "";
+          } else {
+            current += char;
+          }
         } else {
-          secret[${escPath}].val = val
-          o${delim}${path} = ${isCensorFct ? `censor(${censorArgs})` : "censor"}
-          ${circularDetection}
+          current += char;
         }
       }
-    `;
-      }).join("\n");
-    }
-    function dynamicRedactTmpl(hasWildcards, isCensorFct, censorFctTakesPath) {
-      return hasWildcards === true ? `
-    {
-      const { wildcards, wcLen, groupRedact, nestedRedact } = this
-      for (var i = 0; i < wcLen; i++) {
-        const { before, beforeStr, after, nested } = wildcards[i]
-        if (nested === true) {
-          secret[beforeStr] = secret[beforeStr] || []
-          nestedRedact(secret[beforeStr], o, before, after, censor, ${isCensorFct}, ${censorFctTakesPath})
-        } else secret[beforeStr] = groupRedact(o, before, censor, ${isCensorFct}, ${censorFctTakesPath})
+      if (current) {
+        parts.push(current);
       }
+      return parts;
     }
-  ` : "";
-    }
-    function resultTmpl(serialize) {
-      return serialize === false ? `return o` : `
-    var s = this.serialize(o)
-    this.restore(o)
-    return s
-  `;
-    }
-    function strictImpl(strict, serialize) {
-      return strict === true ? `throw Error('fast-redact: primitives cannot be redacted')` : serialize === false ? `return o` : `return this.serialize(o)`;
+    function setValue(obj, parts, value) {
+      let current = obj;
+      for (let i = 0; i < parts.length - 1; i++) {
+        const key = parts[i];
+        if (typeof current !== "object" || current === null || !(key in current)) {
+          return false;
+        }
+        if (typeof current[key] !== "object" || current[key] === null) {
+          return false;
+        }
+        current = current[key];
+      }
+      const lastKey = parts[parts.length - 1];
+      if (lastKey === "*") {
+        if (Array.isArray(current)) {
+          for (let i = 0; i < current.length; i++) {
+            current[i] = value;
+          }
+        } else if (typeof current === "object" && current !== null) {
+          for (const key in current) {
+            if (Object.prototype.hasOwnProperty.call(current, key)) {
+              current[key] = value;
+            }
+          }
+        }
+      } else {
+        if (typeof current === "object" && current !== null && lastKey in current && Object.prototype.hasOwnProperty.call(current, lastKey)) {
+          current[lastKey] = value;
+        }
+      }
+      return true;
     }
-  }
-});
-
-// node_modules/fast-redact/lib/modifiers.js
-var require_modifiers = __commonJS({
-  "node_modules/fast-redact/lib/modifiers.js"(exports2, module2) {
-    "use strict";
-    module2.exports = {
-      groupRedact,
-      groupRestore,
-      nestedRedact,
-      nestedRestore
-    };
-    function groupRestore({ keys, values, target }) {
-      if (target == null || typeof target === "string") return;
-      const length = keys.length;
-      for (var i = 0; i < length; i++) {
-        const k = keys[i];
-        target[k] = values[i];
-      }
-    }
-    function groupRedact(o, path, censor, isCensorFct, censorFctTakesPath) {
-      const target = get(o, path);
-      if (target == null || typeof target === "string") return { keys: null, values: null, target, flat: true };
-      const keys = Object.keys(target);
-      const keysLength = keys.length;
-      const pathLength = path.length;
-      const pathWithKey = censorFctTakesPath ? [...path] : void 0;
-      const values = new Array(keysLength);
-      for (var i = 0; i < keysLength; i++) {
-        const key = keys[i];
-        values[i] = target[key];
-        if (censorFctTakesPath) {
-          pathWithKey[pathLength] = key;
-          target[key] = censor(target[key], pathWithKey);
-        } else if (isCensorFct) {
-          target[key] = censor(target[key]);
-        } else {
-          target[key] = censor;
+    function removeKey(obj, parts) {
+      let current = obj;
+      for (let i = 0; i < parts.length - 1; i++) {
+        const key = parts[i];
+        if (typeof current !== "object" || current === null || !(key in current)) {
+          return false;
+        }
+        if (typeof current[key] !== "object" || current[key] === null) {
+          return false;
+        }
+        current = current[key];
+      }
+      const lastKey = parts[parts.length - 1];
+      if (lastKey === "*") {
+        if (Array.isArray(current)) {
+          for (let i = 0; i < current.length; i++) {
+            current[i] = void 0;
+          }
+        } else if (typeof current === "object" && current !== null) {
+          for (const key in current) {
+            if (Object.prototype.hasOwnProperty.call(current, key)) {
+              delete current[key];
+            }
+          }
+        }
+      } else {
+        if (typeof current === "object" && current !== null && lastKey in current && Object.prototype.hasOwnProperty.call(current, lastKey)) {
+          delete current[lastKey];
         }
       }
-      return { keys, values, target, flat: true };
+      return true;
     }
-    function nestedRestore(instructions) {
-      for (let i = 0; i < instructions.length; i++) {
-        const { target, path, value } = instructions[i];
-        let current = target;
-        for (let i2 = path.length - 1; i2 > 0; i2--) {
-          current = current[path[i2]];
+    var PATH_NOT_FOUND = /* @__PURE__ */ Symbol("PATH_NOT_FOUND");
+    function getValueIfExists(obj, parts) {
+      let current = obj;
+      for (const part of parts) {
+        if (current === null || current === void 0) {
+          return PATH_NOT_FOUND;
+        }
+        if (typeof current !== "object" || current === null) {
+          return PATH_NOT_FOUND;
+        }
+        if (!(part in current)) {
+          return PATH_NOT_FOUND;
         }
-        current[path[0]] = value;
+        current = current[part];
       }
+      return current;
     }
-    function nestedRedact(store, o, path, ns, censor, isCensorFct, censorFctTakesPath) {
-      const target = get(o, path);
-      if (target == null) return;
-      const keys = Object.keys(target);
-      const keysLength = keys.length;
-      for (var i = 0; i < keysLength; i++) {
-        const key = keys[i];
-        specialSet(store, target, key, path, ns, censor, isCensorFct, censorFctTakesPath);
+    function getValue(obj, parts) {
+      let current = obj;
+      for (const part of parts) {
+        if (current === null || current === void 0) {
+          return void 0;
+        }
+        if (typeof current !== "object" || current === null) {
+          return void 0;
+        }
+        current = current[part];
       }
-      return store;
+      return current;
     }
-    function has(obj, prop) {
-      return obj !== void 0 && obj !== null ? "hasOwn" in Object ? Object.hasOwn(obj, prop) : Object.prototype.hasOwnProperty.call(obj, prop) : false;
+    function redactPaths(obj, paths, censor, remove = false) {
+      for (const path of paths) {
+        const parts = parsePath(path);
+        if (parts.includes("*")) {
+          redactWildcardPath(obj, parts, censor, path, remove);
+        } else {
+          if (remove) {
+            removeKey(obj, parts);
+          } else {
+            const value = getValueIfExists(obj, parts);
+            if (value === PATH_NOT_FOUND) {
+              continue;
+            }
+            const actualCensor = typeof censor === "function" ? censor(value, parts) : censor;
+            setValue(obj, parts, actualCensor);
+          }
+        }
+      }
     }
-    function specialSet(store, o, k, path, afterPath, censor, isCensorFct, censorFctTakesPath) {
-      const afterPathLen = afterPath.length;
-      const lastPathIndex = afterPathLen - 1;
-      const originalKey = k;
-      var i = -1;
-      var n;
-      var nv;
-      var ov;
-      var oov = null;
-      var wc = null;
-      var kIsWc;
-      var wcov;
-      var consecutive = false;
-      var level = 0;
-      var depth = 0;
-      var redactPathCurrent = tree();
-      ov = n = o[k];
-      if (typeof n !== "object") return;
-      while (n != null && ++i < afterPathLen) {
-        depth += 1;
-        k = afterPath[i];
-        oov = ov;
-        if (k !== "*" && !wc && !(typeof n === "object" && k in n)) {
-          break;
+    function redactWildcardPath(obj, parts, censor, originalPath, remove = false) {
+      const wildcardIndex = parts.indexOf("*");
+      if (wildcardIndex === parts.length - 1) {
+        const parentParts = parts.slice(0, -1);
+        let current = obj;
+        for (const part of parentParts) {
+          if (current === null || current === void 0) return;
+          if (typeof current !== "object" || current === null) return;
+          current = current[part];
         }
-        if (k === "*") {
-          if (wc === "*") {
-            consecutive = true;
+        if (Array.isArray(current)) {
+          if (remove) {
+            for (let i = 0; i < current.length; i++) {
+              current[i] = void 0;
+            }
+          } else {
+            for (let i = 0; i < current.length; i++) {
+              const indexPath = [...parentParts, i.toString()];
+              const actualCensor = typeof censor === "function" ? censor(current[i], indexPath) : censor;
+              current[i] = actualCensor;
+            }
           }
-          wc = k;
-          if (i !== lastPathIndex) {
-            continue;
+        } else if (typeof current === "object" && current !== null) {
+          if (remove) {
+            const keysToDelete = [];
+            for (const key in current) {
+              if (Object.prototype.hasOwnProperty.call(current, key)) {
+                keysToDelete.push(key);
+              }
+            }
+            for (const key of keysToDelete) {
+              delete current[key];
+            }
+          } else {
+            for (const key in current) {
+              const keyPath = [...parentParts, key];
+              const actualCensor = typeof censor === "function" ? censor(current[key], keyPath) : censor;
+              current[key] = actualCensor;
+            }
           }
         }
-        if (wc) {
-          const wcKeys = Object.keys(n);
-          for (var j = 0; j < wcKeys.length; j++) {
-            const wck = wcKeys[j];
-            wcov = n[wck];
-            kIsWc = k === "*";
-            if (consecutive) {
-              redactPathCurrent = node(redactPathCurrent, wck, depth);
-              level = i;
-              ov = iterateNthLevel(wcov, level - 1, k, path, afterPath, censor, isCensorFct, censorFctTakesPath, originalKey, n, nv, ov, kIsWc, wck, i, lastPathIndex, redactPathCurrent, store, o[originalKey], depth + 1);
-            } else {
-              if (kIsWc || typeof wcov === "object" && wcov !== null && k in wcov) {
-                if (kIsWc) {
-                  ov = wcov;
-                } else {
-                  ov = wcov[k];
-                }
-                nv = i !== lastPathIndex ? ov : isCensorFct ? censorFctTakesPath ? censor(ov, [...path, originalKey, ...afterPath]) : censor(ov) : censor;
-                if (kIsWc) {
-                  const rv = restoreInstr(node(redactPathCurrent, wck, depth), ov, o[originalKey]);
-                  store.push(rv);
-                  n[wck] = nv;
-                } else {
-                  if (wcov[k] === nv) {
-                  } else if (nv === void 0 && censor !== void 0 || has(wcov, k) && nv === ov) {
-                    redactPathCurrent = node(redactPathCurrent, wck, depth);
-                  } else {
-                    redactPathCurrent = node(redactPathCurrent, wck, depth);
-                    const rv = restoreInstr(node(redactPathCurrent, k, depth + 1), ov, o[originalKey]);
-                    store.push(rv);
-                    wcov[k] = nv;
-                  }
-                }
-              }
+      } else {
+        redactIntermediateWildcard(obj, parts, censor, wildcardIndex, originalPath, remove);
+      }
+    }
+    function redactIntermediateWildcard(obj, parts, censor, wildcardIndex, originalPath, remove = false) {
+      const beforeWildcard = parts.slice(0, wildcardIndex);
+      const afterWildcard = parts.slice(wildcardIndex + 1);
+      const pathArray = [];
+      function traverse(current, pathLength) {
+        if (pathLength === beforeWildcard.length) {
+          if (Array.isArray(current)) {
+            for (let i = 0; i < current.length; i++) {
+              pathArray[pathLength] = i.toString();
+              traverse(current[i], pathLength + 1);
+            }
+          } else if (typeof current === "object" && current !== null) {
+            for (const key in current) {
+              pathArray[pathLength] = key;
+              traverse(current[key], pathLength + 1);
             }
           }
-          wc = null;
+        } else if (pathLength < beforeWildcard.length) {
+          const nextKey = beforeWildcard[pathLength];
+          if (current && typeof current === "object" && current !== null && nextKey in current) {
+            pathArray[pathLength] = nextKey;
+            traverse(current[nextKey], pathLength + 1);
+          }
         } else {
-          ov = n[k];
-          redactPathCurrent = node(redactPathCurrent, k, depth);
-          nv = i !== lastPathIndex ? ov : isCensorFct ? censorFctTakesPath ? censor(ov, [...path, originalKey, ...afterPath]) : censor(ov) : censor;
-          if (has(n, k) && nv === ov || nv === void 0 && censor !== void 0) {
+          if (afterWildcard.includes("*")) {
+            const wrappedCensor = typeof censor === "function" ? (value, path) => {
+              const fullPath = [...pathArray.slice(0, pathLength), ...path];
+              return censor(value, fullPath);
+            } : censor;
+            redactWildcardPath(current, afterWildcard, wrappedCensor, originalPath, remove);
           } else {
-            const rv = restoreInstr(redactPathCurrent, ov, o[originalKey]);
-            store.push(rv);
-            n[k] = nv;
+            if (remove) {
+              removeKey(current, afterWildcard);
+            } else {
+              const actualCensor = typeof censor === "function" ? censor(getValue(current, afterWildcard), [...pathArray.slice(0, pathLength), ...afterWildcard]) : censor;
+              setValue(current, afterWildcard, actualCensor);
+            }
           }
-          n = n[k];
         }
-        if (typeof n !== "object") break;
-        if (ov === oov || typeof ov === "undefined") {
+      }
+      if (beforeWildcard.length === 0) {
+        traverse(obj, 0);
+      } else {
+        let current = obj;
+        for (let i = 0; i < beforeWildcard.length; i++) {
+          const part = beforeWildcard[i];
+          if (current === null || current === void 0) return;
+          if (typeof current !== "object" || current === null) return;
+          current = current[part];
+          pathArray[i] = part;
+        }
+        if (current !== null && current !== void 0) {
+          traverse(current, beforeWildcard.length);
         }
       }
     }
-    function get(o, p) {
-      var i = -1;
-      var l = p.length;
-      var n = o;
-      while (n != null && ++i < l) {
-        n = n[p[i]];
+    function buildPathStructure(pathsToClone) {
+      if (pathsToClone.length === 0) {
+        return null;
       }
-      return n;
+      const pathStructure = /* @__PURE__ */ new Map();
+      for (const path of pathsToClone) {
+        const parts = parsePath(path);
+        let current = pathStructure;
+        for (let i = 0; i < parts.length; i++) {
+          const part = parts[i];
+          if (!current.has(part)) {
+            current.set(part, /* @__PURE__ */ new Map());
+          }
+          current = current.get(part);
+        }
+      }
+      return pathStructure;
     }
-    function iterateNthLevel(wcov, level, k, path, afterPath, censor, isCensorFct, censorFctTakesPath, originalKey, n, nv, ov, kIsWc, wck, i, lastPathIndex, redactPathCurrent, store, parent, depth) {
-      if (level === 0) {
-        if (kIsWc || typeof wcov === "object" && wcov !== null && k in wcov) {
-          if (kIsWc) {
-            ov = wcov;
-          } else {
-            ov = wcov[k];
+    function selectiveClone(obj, pathStructure) {
+      if (!pathStructure) {
+        return obj;
+      }
+      function cloneSelectively(source, pathMap, depth = 0) {
+        if (!pathMap || pathMap.size === 0) {
+          return source;
+        }
+        if (source === null || typeof source !== "object") {
+          return source;
+        }
+        if (source instanceof Date) {
+          return new Date(source.getTime());
+        }
+        if (Array.isArray(source)) {
+          const cloned2 = [];
+          for (let i = 0; i < source.length; i++) {
+            const indexStr = i.toString();
+            if (pathMap.has(indexStr) || pathMap.has("*")) {
+              cloned2[i] = cloneSelectively(source[i], pathMap.get(indexStr) || pathMap.get("*"));
+            } else {
+              cloned2[i] = source[i];
+            }
           }
-          nv = i !== lastPathIndex ? ov : isCensorFct ? censorFctTakesPath ? censor(ov, [...path, originalKey, ...afterPath]) : censor(ov) : censor;
-          if (kIsWc) {
-            const rv = restoreInstr(redactPathCurrent, ov, parent);
-            store.push(rv);
-            n[wck] = nv;
-          } else {
-            if (wcov[k] === nv) {
-            } else if (nv === void 0 && censor !== void 0 || has(wcov, k) && nv === ov) {
+          return cloned2;
+        }
+        const cloned = Object.create(Object.getPrototypeOf(source));
+        for (const key in source) {
+          if (Object.prototype.hasOwnProperty.call(source, key)) {
+            if (pathMap.has(key) || pathMap.has("*")) {
+              cloned[key] = cloneSelectively(source[key], pathMap.get(key) || pathMap.get("*"));
             } else {
-              const rv = restoreInstr(node(redactPathCurrent, k, depth + 1), ov, parent);
-              store.push(rv);
-              wcov[k] = nv;
+              cloned[key] = source[key];
             }
           }
         }
+        return cloned;
+      }
+      return cloneSelectively(obj, pathStructure);
+    }
+    function validatePath(path) {
+      if (typeof path !== "string") {
+        throw new Error("Paths must be (non-empty) strings");
       }
-      for (const key in wcov) {
-        if (typeof wcov[key] === "object") {
-          redactPathCurrent = node(redactPathCurrent, key, depth);
-          iterateNthLevel(wcov[key], level - 1, k, path, afterPath, censor, isCensorFct, censorFctTakesPath, originalKey, n, nv, ov, kIsWc, wck, i, lastPathIndex, redactPathCurrent, store, parent, depth + 1);
+      if (path === "") {
+        throw new Error("Invalid redaction path ()");
+      }
+      if (path.includes("..")) {
+        throw new Error(`Invalid redaction path (${path})`);
+      }
+      if (path.includes(",")) {
+        throw new Error(`Invalid redaction path (${path})`);
+      }
+      let bracketCount = 0;
+      let inQuotes = false;
+      let quoteChar = "";
+      for (let i = 0; i < path.length; i++) {
+        const char = path[i];
+        if ((char === '"' || char === "'") && bracketCount > 0) {
+          if (!inQuotes) {
+            inQuotes = true;
+            quoteChar = char;
+          } else if (char === quoteChar) {
+            inQuotes = false;
+            quoteChar = "";
+          }
+        } else if (char === "[" && !inQuotes) {
+          bracketCount++;
+        } else if (char === "]" && !inQuotes) {
+          bracketCount--;
+          if (bracketCount < 0) {
+            throw new Error(`Invalid redaction path (${path})`);
+          }
         }
       }
-    }
-    function tree() {
-      return { parent: null, key: null, children: [], depth: 0 };
-    }
-    function node(parent, key, depth) {
-      if (parent.depth === depth) {
-        return node(parent.parent, key, depth);
+      if (bracketCount !== 0) {
+        throw new Error(`Invalid redaction path (${path})`);
       }
-      var child = {
-        parent,
-        key,
-        depth,
-        children: []
-      };
-      parent.children.push(child);
-      return child;
     }
-    function restoreInstr(node2, value, target) {
-      let current = node2;
-      const path = [];
-      do {
-        path.push(current.key);
-        current = current.parent;
-      } while (current.parent != null);
-      return { path, value, target };
+    function validatePaths(paths) {
+      if (!Array.isArray(paths)) {
+        throw new TypeError("paths must be an array");
+      }
+      for (const path of paths) {
+        validatePath(path);
+      }
     }
-  }
-});
-
-// node_modules/fast-redact/lib/restorer.js
-var require_restorer = __commonJS({
-  "node_modules/fast-redact/lib/restorer.js"(exports2, module2) {
-    "use strict";
-    var { groupRestore, nestedRestore } = require_modifiers();
-    module2.exports = restorer;
-    function restorer() {
-      return function compileRestore() {
-        if (this.restore) {
-          this.restore.state.secret = this.secret;
-          return;
+    function slowRedact(options = {}) {
+      const {
+        paths = [],
+        censor = "[REDACTED]",
+        serialize = JSON.stringify,
+        strict = true,
+        remove = false
+      } = options;
+      validatePaths(paths);
+      const pathStructure = buildPathStructure(paths);
+      return function redact(obj) {
+        if (strict && (obj === null || typeof obj !== "object")) {
+          if (obj === null || obj === void 0) {
+            return serialize ? serialize(obj) : obj;
+          }
+          if (typeof obj !== "object") {
+            return serialize ? serialize(obj) : obj;
+          }
+        }
+        const cloned = selectiveClone(obj, pathStructure);
+        const original = obj;
+        let actualCensor = censor;
+        if (typeof censor === "function") {
+          actualCensor = censor;
+        }
+        redactPaths(cloned, paths, actualCensor, remove);
+        if (serialize === false) {
+          cloned.restore = function() {
+            return deepClone(original);
+          };
+          return cloned;
+        }
+        if (typeof serialize === "function") {
+          return serialize(cloned);
         }
-        const { secret, wcLen } = this;
-        const paths = Object.keys(secret);
-        const resetters = resetTmpl(secret, paths);
-        const hasWildcards = wcLen > 0;
-        const state = hasWildcards ? { secret, groupRestore, nestedRestore } : { secret };
-        this.restore = Function(
-          "o",
-          restoreTmpl(resetters, paths, hasWildcards)
-        ).bind(state);
-        this.restore.state = state;
+        return JSON.stringify(cloned);
       };
     }
-    function resetTmpl(secret, paths) {
-      return paths.map((path) => {
-        const { circle, escPath, leadingBracket } = secret[path];
-        const delim = leadingBracket ? "" : ".";
-        const reset = circle ? `o.${circle} = secret[${escPath}].val` : `o${delim}${path} = secret[${escPath}].val`;
-        const clear = `secret[${escPath}].val = undefined`;
-        return `
-      if (secret[${escPath}].val !== undefined) {
-        try { ${reset} } catch (e) {}
-        ${clear}
-      }
-    `;
-      }).join("");
-    }
-    function restoreTmpl(resetters, paths, hasWildcards) {
-      const dynamicReset = hasWildcards === true ? `
-    const keys = Object.keys(secret)
-    const len = keys.length
-    for (var i = len - 1; i >= ${paths.length}; i--) {
-      const k = keys[i]
-      const o = secret[k]
-      if (o) {
-        if (o.flat === true) this.groupRestore(o)
-        else this.nestedRestore(o)
-        secret[k] = null
-      }
-    }
-  ` : "";
-      return `
-    const secret = this.secret
-    ${dynamicReset}
-    ${resetters}
-    return o
-  `;
-    }
-  }
-});
-
-// node_modules/fast-redact/lib/state.js
-var require_state3 = __commonJS({
-  "node_modules/fast-redact/lib/state.js"(exports2, module2) {
-    "use strict";
-    module2.exports = state;
-    function state(o) {
-      const {
-        secret,
-        censor,
-        compileRestore,
-        serialize,
-        groupRedact,
-        nestedRedact,
-        wildcards,
-        wcLen
-      } = o;
-      const builder = [{ secret, censor, compileRestore }];
-      if (serialize !== false) builder.push({ serialize });
-      if (wcLen > 0) builder.push({ groupRedact, nestedRedact, wildcards, wcLen });
-      return Object.assign(...builder);
-    }
-  }
-});
-
-// node_modules/fast-redact/index.js
-var require_fast_redact = __commonJS({
-  "node_modules/fast-redact/index.js"(exports2, module2) {
-    "use strict";
-    var validator = require_validator();
-    var parse2 = require_parse();
-    var redactor = require_redactor();
-    var restorer = require_restorer();
-    var { groupRedact, nestedRedact } = require_modifiers();
-    var state = require_state3();
-    var rx = require_rx();
-    var validate = validator();
-    var noop = (o) => o;
-    noop.restore = noop;
-    var DEFAULT_CENSOR = "[REDACTED]";
-    fastRedact.rx = rx;
-    fastRedact.validator = validator;
-    module2.exports = fastRedact;
-    function fastRedact(opts = {}) {
-      const paths = Array.from(new Set(opts.paths || []));
-      const serialize = "serialize" in opts ? opts.serialize === false ? opts.serialize : typeof opts.serialize === "function" ? opts.serialize : JSON.stringify : JSON.stringify;
-      const remove = opts.remove;
-      if (remove === true && serialize !== JSON.stringify) {
-        throw Error("fast-redact \u2013 remove option may only be set when serializer is JSON.stringify");
-      }
-      const censor = remove === true ? void 0 : "censor" in opts ? opts.censor : DEFAULT_CENSOR;
-      const isCensorFct = typeof censor === "function";
-      const censorFctTakesPath = isCensorFct && censor.length > 1;
-      if (paths.length === 0) return serialize || noop;
-      validate({ paths, serialize, censor });
-      const { wildcards, wcLen, secret } = parse2({ paths, censor });
-      const compileRestore = restorer();
-      const strict = "strict" in opts ? opts.strict : true;
-      return redactor({ secret, wcLen, serialize, strict, isCensorFct, censorFctTakesPath }, state({
-        secret,
-        censor,
-        compileRestore,
-        serialize,
-        groupRedact,
-        nestedRedact,
-        wildcards,
-        wcLen
-      }));
-    }
+    module2.exports = slowRedact;
   }
 });
 
@@ -13934,17 +13829,13 @@ var require_symbols = __commonJS({
 var require_redaction = __commonJS({
   "node_modules/pino/lib/redaction.js"(exports2, module2) {
     "use strict";
-    var fastRedact = require_fast_redact();
+    var Redact = require_redact();
     var { redactFmtSym, wildcardFirstSym } = require_symbols();
-    var { rx, validator } = fastRedact;
-    var validate = validator({
-      ERR_PATHS_MUST_BE_STRINGS: () => "pino \u2013 redacted paths must be strings",
-      ERR_INVALID_PATH: (s) => `pino \u2013 redact paths array contains an invalid path (${s})`
-    });
+    var rx = /[^.[\]]+|\[([^[\]]*?)\]/g;
     var CENSOR = "[Redacted]";
     var strict = false;
     function redaction(opts, serialize) {
-      const { paths, censor } = handle(opts);
+      const { paths, censor, remove } = handle(opts);
       const shape = paths.reduce((o, str) => {
         rx.lastIndex = 0;
         const first = rx.exec(str);
@@ -13977,7 +13868,7 @@ var require_redaction = __commonJS({
         return o;
       }, {});
       const result = {
-        [redactFmtSym]: fastRedact({ paths, censor, serialize, strict })
+        [redactFmtSym]: Redact({ paths, censor, serialize, strict, remove })
       };
       const topCensor = (...args) => {
         return typeof censor === "function" ? serialize(censor(...args)) : serialize(censor);
@@ -13989,11 +13880,12 @@ var require_redaction = __commonJS({
           const wrappedCensor = typeof censor === "function" ? (value, path) => {
             return censor(value, [k, ...path]);
           } : censor;
-          o[k] = fastRedact({
+          o[k] = Redact({
             paths: shape[k],
             censor: wrappedCensor,
             serialize,
-            strict
+            strict,
+            remove
           });
         }
         return o;
@@ -14002,7 +13894,6 @@ var require_redaction = __commonJS({
     function handle(opts) {
       if (Array.isArray(opts)) {
         opts = { paths: opts, censor: CENSOR };
-        validate(opts);
         return opts;
       }
       let { paths, censor = CENSOR, remove } = opts;
@@ -14010,8 +13901,7 @@ var require_redaction = __commonJS({
         throw Error("pino \u2013 redact must contain an array of strings");
       }
       if (remove === true) censor = void 0;
-      validate({ paths, censor });
-      return { paths, censor };
+      return { paths, censor, remove };
     }
     module2.exports = redaction;
   }
@@ -14025,7 +13915,26 @@ var require_time = __commonJS({
     var epochTime = () => `,"time":${Date.now()}`;
     var unixTime = () => `,"time":${Math.round(Date.now() / 1e3)}`;
     var isoTime = () => `,"time":"${new Date(Date.now()).toISOString()}"`;
-    module2.exports = { nullTime, epochTime, unixTime, isoTime };
+    var NS_PER_MS = 1000000n;
+    var NS_PER_SEC = 1000000000n;
+    var startWallTimeNs = BigInt(Date.now()) * NS_PER_MS;
+    var startHrTime = process.hrtime.bigint();
+    var isoTimeNano = () => {
+      const elapsedNs = process.hrtime.bigint() - startHrTime;
+      const currentTimeNs = startWallTimeNs + elapsedNs;
+      const secondsSinceEpoch = currentTimeNs / NS_PER_SEC;
+      const nanosWithinSecond = currentTimeNs % NS_PER_SEC;
+      const msSinceEpoch = Number(secondsSinceEpoch * 1000n + nanosWithinSecond / 1000000n);
+      const date = new Date(msSinceEpoch);
+      const year = date.getUTCFullYear();
+      const month = (date.getUTCMonth() + 1).toString().padStart(2, "0");
+      const day = date.getUTCDate().toString().padStart(2, "0");
+      const hours = date.getUTCHours().toString().padStart(2, "0");
+      const minutes = date.getUTCMinutes().toString().padStart(2, "0");
+      const seconds = date.getUTCSeconds().toString().padStart(2, "0");
+      return `,"time":"${year}-${month}-${day}T${hours}:${minutes}:${seconds}.${nanosWithinSecond.toString().padStart(9, "0")}Z"`;
+    };
+    module2.exports = { nullTime, epochTime, unixTime, isoTime, isoTimeNano };
   }
 });
 
@@ -14192,11 +14101,14 @@ var require_sonic_boom = __commonJS({
     var inherits = require("util").inherits;
     var path = require("path");
     var sleep = require_atomic_sleep();
+    var assert = require("assert");
     var BUSY_WRITE_TIMEOUT = 100;
     var kEmptyBuffer = Buffer.allocUnsafe(0);
     var MAX_WRITE = 16 * 1024;
     var kContentModeBuffer = "buffer";
     var kContentModeUtf8 = "utf8";
+    var [major, minor] = (process.versions.node || "0.0").split(".").map(Number);
+    var kCopyBuffer = major >= 22 && minor >= 7;
     function openFile(file, sonic) {
       sonic._opening = true;
       sonic._writing = true;
@@ -14261,7 +14173,7 @@ var require_sonic_boom = __commonJS({
       if (!(this instanceof SonicBoom)) {
         return new SonicBoom(opts);
       }
-      let { fd, dest, minLength, maxLength, maxWrite, sync, append = true, mkdir, retryEAGAIN, fsync, contentMode, mode } = opts || {};
+      let { fd, dest, minLength, maxLength, maxWrite, periodicFlush, sync, append = true, mkdir, retryEAGAIN, fsync, contentMode, mode } = opts || {};
       fd = fd || dest;
       this._len = 0;
       this.fd = -1;
@@ -14278,6 +14190,8 @@ var require_sonic_boom = __commonJS({
       this.minLength = minLength || 0;
       this.maxLength = maxLength || 0;
       this.maxWrite = maxWrite || MAX_WRITE;
+      this._periodicFlush = periodicFlush || 0;
+      this._periodicFlushTimer = void 0;
       this.sync = sync || false;
       this.writable = true;
       this._fsync = fsync || false;
@@ -14301,8 +14215,18 @@ var require_sonic_boom = __commonJS({
         this.flush = flush;
         this.flushSync = flushSync;
         this._actualWrite = actualWrite;
-        fsWriteSync = () => fs.writeSync(this.fd, this._writingBuf, "utf8");
-        fsWrite = () => fs.write(this.fd, this._writingBuf, "utf8", this.release);
+        fsWriteSync = () => {
+          if (Buffer.isBuffer(this._writingBuf)) {
+            return fs.writeSync(this.fd, this._writingBuf);
+          }
+          return fs.writeSync(this.fd, this._writingBuf, "utf8");
+        };
+        fsWrite = () => {
+          if (Buffer.isBuffer(this._writingBuf)) {
+            return fs.write(this.fd, this._writingBuf, this.release);
+          }
+          return fs.write(this.fd, this._writingBuf, "utf8", this.release);
+        };
       } else {
         throw new Error(`SonicBoom supports "${kContentModeUtf8}" and "${kContentModeBuffer}", but passed ${contentMode}`);
       }
@@ -14391,13 +14315,17 @@ var require_sonic_boom = __commonJS({
           this._asyncDrainScheduled = false;
         }
       });
+      if (this._periodicFlush !== 0) {
+        this._periodicFlushTimer = setInterval(() => this.flush(null), this._periodicFlush);
+        this._periodicFlushTimer.unref();
+      }
     }
     function releaseWritingBuf(writingBuf, len, n) {
-      if (typeof writingBuf === "string" && Buffer.byteLength(writingBuf) !== n) {
-        n = Buffer.from(writingBuf).subarray(0, n).toString().length;
+      if (typeof writingBuf === "string") {
+        writingBuf = Buffer.from(writingBuf);
       }
       len = Math.max(len - n, 0);
-      writingBuf = writingBuf.slice(n);
+      writingBuf = writingBuf.subarray(n);
       return { writingBuf, len };
     }
     function emitDrain(sonic) {
@@ -14420,14 +14348,16 @@ var require_sonic_boom = __commonJS({
       if (this.destroyed) {
         throw new Error("SonicBoom destroyed");
       }
-      const len = this._len + data.length;
+      data = "" + data;
+      const dataLen = Buffer.byteLength(data);
+      const len = this._len + dataLen;
       const bufs = this._bufs;
       if (this.maxLength && len > this.maxLength) {
         this.emit("drop", data);
         return this._len < this._hwm;
       }
-      if (bufs.length === 0 || bufs[bufs.length - 1].length + data.length > this.maxWrite) {
-        bufs.push("" + data);
+      if (bufs.length === 0 || Buffer.byteLength(bufs[bufs.length - 1]) + dataLen > this.maxWrite) {
+        bufs.push(data);
       } else {
         bufs[bufs.length - 1] += data;
       }
@@ -14465,10 +14395,14 @@ var require_sonic_boom = __commonJS({
       this._flushPending = true;
       const onDrain = () => {
         if (!this._fsync) {
-          fs.fsync(this.fd, (err) => {
-            this._flushPending = false;
+          try {
+            fs.fsync(this.fd, (err) => {
+              this._flushPending = false;
+              cb(err);
+            });
+          } catch (err) {
             cb(err);
-          });
+          }
         } else {
           this._flushPending = false;
           cb();
@@ -14608,12 +14542,12 @@ var require_sonic_boom = __commonJS({
         this._writingBuf = "";
       }
       let buf = "";
-      while (this._bufs.length || buf) {
+      while (this._bufs.length || buf.length) {
         if (buf.length <= 0) {
           buf = this._bufs[0];
         }
         try {
-          const n = fs.writeSync(this.fd, buf, "utf8");
+          const n = Buffer.isBuffer(buf) ? fs.writeSync(this.fd, buf) : fs.writeSync(this.fd, buf, "utf8");
           const releasedBufObj = releaseWritingBuf(buf, this._len, n);
           buf = releasedBufObj.writingBuf;
           this._len = releasedBufObj.len;
@@ -14675,16 +14609,16 @@ var require_sonic_boom = __commonJS({
     function actualWrite() {
       const release = this.release;
       this._writing = true;
-      this._writingBuf = this._writingBuf || this._bufs.shift() || "";
+      this._writingBuf = this._writingBuf.length ? this._writingBuf : this._bufs.shift() || "";
       if (this.sync) {
         try {
-          const written = fs.writeSync(this.fd, this._writingBuf, "utf8");
+          const written = Buffer.isBuffer(this._writingBuf) ? fs.writeSync(this.fd, this._writingBuf) : fs.writeSync(this.fd, this._writingBuf, "utf8");
           release(null, written);
         } catch (err) {
           release(err);
         }
       } else {
-        fs.write(this.fd, this._writingBuf, "utf8", release);
+        fs.write(this.fd, this._writingBuf, release);
       }
     }
     function actualWriteBuffer() {
@@ -14699,6 +14633,9 @@ var require_sonic_boom = __commonJS({
           release(err);
         }
       } else {
+        if (kCopyBuffer) {
+          this._writingBuf = Buffer.from(this._writingBuf);
+        }
         fs.write(this.fd, this._writingBuf, release);
       }
     }
@@ -14707,10 +14644,17 @@ var require_sonic_boom = __commonJS({
         sonic.once("ready", actualClose.bind(null, sonic));
         return;
       }
+      if (sonic._periodicFlushTimer !== void 0) {
+        clearInterval(sonic._periodicFlushTimer);
+      }
       sonic.destroyed = true;
       sonic._bufs = [];
       sonic._lens = [];
-      fs.fsync(sonic.fd, closeWrapped);
+      assert(typeof sonic.fd === "number", `sonic.fd must be a number, got ${typeof sonic.fd}`);
+      try {
+        fs.fsync(sonic.fd, closeWrapped);
+      } catch {
+      }
       function closeWrapped() {
         if (sonic.fd !== 1 && sonic.fd !== 2) {
           fs.close(sonic.fd, done);
@@ -14834,41 +14778,36 @@ var require_package2 = __commonJS({
   "node_modules/thread-stream/package.json"(exports2, module2) {
     module2.exports = {
       name: "thread-stream",
-      version: "2.7.0",
+      version: "4.2.0",
       description: "A streaming way to send data to a Node.js Worker Thread",
       main: "index.js",
       types: "index.d.ts",
+      engines: {
+        node: ">=20"
+      },
       dependencies: {
-        "real-require": "^0.2.0"
+        "real-require": "^1.0.0"
       },
       devDependencies: {
-        "@types/node": "^20.1.0",
-        "@types/tap": "^15.0.0",
-        "@yao-pkg/pkg": "^5.11.5",
+        "@types/node": "^25.0.2",
+        "@yao-pkg/pkg": "^6.0.0",
+        borp: "^1.0.0",
         desm: "^1.3.0",
+        eslint: "^9.39.1",
         fastbench: "^1.0.1",
-        husky: "^9.0.6",
-        "pino-elasticsearch": "^8.0.0",
-        "sonic-boom": "^3.0.0",
-        standard: "^17.0.0",
-        tap: "^16.2.0",
+        neostandard: "^0.13.0",
+        "pino-elasticsearch": "^9.0.0",
+        "sonic-boom": "^5.0.0",
         "ts-node": "^10.8.0",
-        typescript: "^5.3.2",
-        "why-is-node-running": "^2.2.2"
+        typescript: "~5.7.3"
       },
       scripts: {
-        test: 'standard && npm run transpile && tap "test/**/*.test.*js" && tap --ts test/*.test.*ts',
-        "test:ci": "standard && npm run transpile && npm run test:ci:js && npm run test:ci:ts",
-        "test:ci:js": 'tap --no-check-coverage --timeout=120 --coverage-report=lcovonly "test/**/*.test.*js"',
-        "test:ci:ts": 'tap --ts --no-check-coverage --coverage-report=lcovonly "test/**/*.test.*ts"',
-        "test:yarn": 'npm run transpile && tap "test/**/*.test.js" --no-check-coverage',
-        transpile: "sh ./test/ts/transpile.sh",
-        prepare: "husky install"
-      },
-      standard: {
-        ignore: [
-          "test/ts/**/*"
-        ]
+        build: "tsc --noEmit",
+        lint: "eslint",
+        test: 'npm run lint && npm run build && npm run transpile && borp --pattern "test/*.test.{js,mjs}"',
+        "test:ci": 'npm run lint && npm run transpile && borp --pattern "test/*.test.{js,mjs}"',
+        "test:yarn": 'npm run transpile && borp --pattern "test/*.test.js"',
+        transpile: "sh ./test/ts/transpile.sh"
       },
       repository: {
         type: "git",
@@ -14894,55 +14833,56 @@ var require_package2 = __commonJS({
 var require_wait = __commonJS({
   "node_modules/thread-stream/lib/wait.js"(exports2, module2) {
     "use strict";
-    var MAX_TIMEOUT = 1e3;
+    var WAIT_MS = 1e4;
     function wait(state, index, expected, timeout, done) {
-      const max = Date.now() + timeout;
-      let current = Atomics.load(state, index);
-      if (current === expected) {
-        done(null, "ok");
-        return;
-      }
-      let prior = current;
-      const check = (backoff) => {
-        if (Date.now() > max) {
+      const max = timeout === Infinity ? Infinity : Date.now() + timeout;
+      const check = () => {
+        const current = Atomics.load(state, index);
+        if (current === expected) {
+          done(null, "ok");
+          return;
+        }
+        if (max !== Infinity && Date.now() > max) {
           done(null, "timed-out");
+          return;
+        }
+        const remaining = max === Infinity ? WAIT_MS : Math.min(WAIT_MS, Math.max(1, max - Date.now()));
+        const result = Atomics.waitAsync(state, index, current, remaining);
+        if (result.async) {
+          result.value.then(check);
         } else {
-          setTimeout(() => {
-            prior = current;
-            current = Atomics.load(state, index);
-            if (current === prior) {
-              check(backoff >= MAX_TIMEOUT ? MAX_TIMEOUT : backoff * 2);
-            } else {
-              if (current === expected) done(null, "ok");
-              else done(null, "not-equal");
-            }
-          }, backoff);
+          setImmediate(check);
         }
       };
-      check(1);
+      check();
     }
     function waitDiff(state, index, expected, timeout, done) {
-      const max = Date.now() + timeout;
-      let current = Atomics.load(state, index);
-      if (current !== expected) {
-        done(null, "ok");
-        return;
-      }
-      const check = (backoff) => {
-        if (Date.now() > max) {
+      const max = timeout === Infinity ? Infinity : Date.now() + timeout;
+      const check = () => {
+        const current = Atomics.load(state, index);
+        if (current !== expected) {
+          done(null, "ok");
+          return;
+        }
+        if (max !== Infinity && Date.now() > max) {
           done(null, "timed-out");
-        } else {
-          setTimeout(() => {
-            current = Atomics.load(state, index);
-            if (current !== expected) {
+          return;
+        }
+        const remaining = max === Infinity ? WAIT_MS : Math.min(WAIT_MS, Math.max(1, max - Date.now()));
+        const result = Atomics.waitAsync(state, index, expected, remaining);
+        if (result.async) {
+          result.value.then((res) => {
+            if (res === "ok") {
               done(null, "ok");
-            } else {
-              check(backoff >= MAX_TIMEOUT ? MAX_TIMEOUT : backoff * 2);
+              return;
             }
-          }, backoff);
+            check();
+          });
+        } else {
+          setImmediate(check);
         }
       };
-      check(1);
+      check();
     }
     module2.exports = { wait, waitDiff };
   }
@@ -14952,11 +14892,13 @@ var require_wait = __commonJS({
 var require_indexes = __commonJS({
   "node_modules/thread-stream/lib/indexes.js"(exports2, module2) {
     "use strict";
+    var SEQ_INDEX = 2;
     var WRITE_INDEX = 4;
     var READ_INDEX = 8;
     module2.exports = {
       WRITE_INDEX,
-      READ_INDEX
+      READ_INDEX,
+      SEQ_INDEX
     };
   }
 });
@@ -14973,12 +14915,27 @@ var require_thread_stream = __commonJS({
     var { wait } = require_wait();
     var {
       WRITE_INDEX,
-      READ_INDEX
+      READ_INDEX,
+      SEQ_INDEX
     } = require_indexes();
     var buffer = require("buffer");
     var assert = require("assert");
     var kImpl = /* @__PURE__ */ Symbol("kImpl");
     var MAX_STRING = buffer.constants.MAX_STRING_LENGTH;
+    function noop() {
+    }
+    function updateState(stream, fn) {
+      Atomics.add(stream[kImpl].state, SEQ_INDEX, 1);
+      fn();
+      Atomics.add(stream[kImpl].state, SEQ_INDEX, 1);
+      Atomics.notify(stream[kImpl].state, SEQ_INDEX);
+    }
+    function resetIndexes(stream) {
+      updateState(stream, () => {
+        Atomics.store(stream[kImpl].state, READ_INDEX, 0);
+        Atomics.store(stream[kImpl].state, WRITE_INDEX, 0);
+      });
+    }
     var FakeWeakRef = class {
       constructor(value) {
         this._value = value;
@@ -15007,6 +14964,7 @@ var require_thread_stream = __commonJS({
       const toExecute = bundlerOverrides["thread-stream-worker"] || join2(__dirname, "lib", "worker.js");
       const worker = new Worker(toExecute, {
         ...opts.workerOpts,
+        name: opts.workerOpts?.name || "thread-stream",
         trackUnmanagedFds: false,
         workerData: {
           filename: filename.indexOf("file://") === 0 ? filename : pathToFileURL(filename).href,
@@ -15034,50 +14992,37 @@ var require_thread_stream = __commonJS({
       }
     }
     function nextFlush(stream) {
-      const writeIndex = Atomics.load(stream[kImpl].state, WRITE_INDEX);
-      let leftover = stream[kImpl].data.length - writeIndex;
-      if (leftover > 0) {
-        if (stream[kImpl].buf.length === 0) {
-          stream[kImpl].flushing = false;
-          if (stream[kImpl].ending) {
-            end(stream);
-          } else if (stream[kImpl].needDrain) {
-            process.nextTick(drain, stream);
+      while (true) {
+        const writeIndex = Atomics.load(stream[kImpl].state, WRITE_INDEX);
+        const leftover = stream[kImpl].data.length - writeIndex;
+        if (leftover > 0) {
+          if (stream[kImpl].bufLen === 0) {
+            stream[kImpl].flushing = false;
+            if (stream[kImpl].ending) {
+              end(stream);
+            } else if (stream[kImpl].needDrain) {
+              process.nextTick(drain, stream);
+            }
+            return;
           }
-          return;
+          write(stream, leftover, noop);
+          continue;
         }
-        let toWrite = stream[kImpl].buf.slice(0, leftover);
-        let toWriteBytes = Buffer.byteLength(toWrite);
-        if (toWriteBytes <= leftover) {
-          stream[kImpl].buf = stream[kImpl].buf.slice(leftover);
-          write(stream, toWrite, nextFlush.bind(null, stream));
-        } else {
-          stream.flush(() => {
+        if (leftover === 0) {
+          if (writeIndex === 0 && stream[kImpl].bufLen === 0) {
+            return;
+          }
+          waitForRead(stream, () => {
             if (stream.destroyed) {
               return;
             }
-            Atomics.store(stream[kImpl].state, READ_INDEX, 0);
-            Atomics.store(stream[kImpl].state, WRITE_INDEX, 0);
-            while (toWriteBytes > stream[kImpl].data.length) {
-              leftover = leftover / 2;
-              toWrite = stream[kImpl].buf.slice(0, leftover);
-              toWriteBytes = Buffer.byteLength(toWrite);
-            }
-            stream[kImpl].buf = stream[kImpl].buf.slice(leftover);
-            write(stream, toWrite, nextFlush.bind(null, stream));
+            resetIndexes(stream);
+            nextFlush(stream);
           });
-        }
-      } else if (leftover === 0) {
-        if (writeIndex === 0 && stream[kImpl].buf.length === 0) {
           return;
         }
-        stream.flush(() => {
-          Atomics.store(stream[kImpl].state, READ_INDEX, 0);
-          Atomics.store(stream[kImpl].state, WRITE_INDEX, 0);
-          nextFlush(stream);
-        });
-      } else {
         destroy(stream, new Error("overwritten"));
+        return;
       }
     }
     function onWorkerMessage(msg) {
@@ -15087,10 +15032,13 @@ var require_thread_stream = __commonJS({
         this.terminate();
         return;
       }
+      if (msg?.code == null) {
+        return;
+      }
       switch (msg.code) {
         case "READY":
           this.stream = new WeakRef2(stream);
-          stream.flush(() => {
+          waitForRead(stream, () => {
             stream[kImpl].ready = true;
             stream.emit("ready");
           });
@@ -15105,6 +15053,18 @@ var require_thread_stream = __commonJS({
             stream.emit(msg.name, msg.args);
           }
           break;
+        case "FLUSHED": {
+          if (msg.context !== "thread-stream") {
+            destroy(stream, new Error("this should not happen: " + msg.code));
+            break;
+          }
+          const cb = stream[kImpl].flushCallbacks.get(msg.id);
+          if (cb) {
+            stream[kImpl].flushCallbacks.delete(msg.id);
+            process.nextTick(cb);
+          }
+          break;
+        }
         case "WARNING":
           process.emitWarning(msg.err);
           break;
@@ -15143,13 +15103,18 @@ var require_thread_stream = __commonJS({
         this[kImpl].finished = false;
         this[kImpl].errored = null;
         this[kImpl].closed = false;
-        this[kImpl].buf = "";
+        this[kImpl].buf = [];
+        this[kImpl].bufHead = 0;
+        this[kImpl].bufLen = 0;
+        this[kImpl].flushCallbacks = /* @__PURE__ */ new Map();
+        this[kImpl].nextFlushId = 0;
         this.worker = createWorker(this, opts);
         this.on("message", (message, transferList) => {
           this.worker.postMessage(message, transferList);
         });
       }
       write(data) {
+        const dataBuf = Buffer.isBuffer(data) ? data : Buffer.from(data);
         if (this[kImpl].destroyed) {
           error(this, new Error("the worker has exited"));
           return false;
@@ -15158,7 +15123,7 @@ var require_thread_stream = __commonJS({
           error(this, new Error("the worker is ending"));
           return false;
         }
-        if (this[kImpl].flushing && this[kImpl].buf.length + data.length >= MAX_STRING) {
+        if (this[kImpl].flushing && this[kImpl].bufLen + dataBuf.length >= MAX_STRING) {
           try {
             writeSync(this);
             this[kImpl].flushing = true;
@@ -15167,7 +15132,8 @@ var require_thread_stream = __commonJS({
             return false;
           }
         }
-        this[kImpl].buf += data;
+        this[kImpl].buf.push(dataBuf);
+        this[kImpl].bufLen += dataBuf.length;
         if (this[kImpl].sync) {
           try {
             writeSync(this);
@@ -15181,7 +15147,7 @@ var require_thread_stream = __commonJS({
           this[kImpl].flushing = true;
           setImmediate(nextFlush, this);
         }
-        this[kImpl].needDrain = this[kImpl].data.length - this[kImpl].buf.length - Atomics.load(this[kImpl].state, WRITE_INDEX) <= 0;
+        this[kImpl].needDrain = this[kImpl].data.length - this[kImpl].bufLen - Atomics.load(this[kImpl].state, WRITE_INDEX) <= 0;
         return !this[kImpl].needDrain;
       }
       end() {
@@ -15192,24 +15158,13 @@ var require_thread_stream = __commonJS({
         end(this);
       }
       flush(cb) {
-        if (this[kImpl].destroyed) {
-          if (typeof cb === "function") {
-            process.nextTick(cb, new Error("the worker has exited"));
-          }
-          return;
-        }
-        const writeIndex = Atomics.load(this[kImpl].state, WRITE_INDEX);
-        wait(this[kImpl].state, READ_INDEX, writeIndex, Infinity, (err, res) => {
+        cb = typeof cb === "function" ? cb : noop;
+        flushBuffer(this, (err) => {
           if (err) {
-            destroy(this, err);
             process.nextTick(cb, err);
             return;
           }
-          if (res === "not-equal") {
-            this.flush(cb);
-            return;
-          }
-          process.nextTick(cb);
+          requestWorkerFlush(this, cb);
         });
       }
       flushSync() {
@@ -15253,6 +15208,79 @@ var require_thread_stream = __commonJS({
         return this[kImpl].errored;
       }
     };
+    function flushBuffer(stream, cb) {
+      if (stream[kImpl].destroyed) {
+        process.nextTick(cb, new Error("the worker has exited"));
+        return;
+      }
+      if (!stream[kImpl].sync && (stream[kImpl].flushing || stream[kImpl].bufLen > 0)) {
+        setImmediate(flushBuffer, stream, cb);
+        return;
+      }
+      waitForRead(stream, cb);
+    }
+    function waitForRead(stream, cb) {
+      const writeIndex = Atomics.load(stream[kImpl].state, WRITE_INDEX);
+      wait(stream[kImpl].state, READ_INDEX, writeIndex, Infinity, (err, res) => {
+        if (err) {
+          destroy(stream, err);
+          cb(err);
+          return;
+        }
+        if (res !== "ok") {
+          waitForRead(stream, cb);
+          return;
+        }
+        cb();
+      });
+    }
+    function requestWorkerFlush(stream, cb) {
+      if (stream[kImpl].destroyed) {
+        process.nextTick(cb, new Error("the worker has exited"));
+        return;
+      }
+      if (!stream[kImpl].ready) {
+        const onReady = () => {
+          cleanup();
+          requestWorkerFlush(stream, cb);
+        };
+        const onClose = () => {
+          cleanup();
+          process.nextTick(cb, new Error("the worker has exited"));
+        };
+        const cleanup = () => {
+          stream.off("ready", onReady);
+          stream.off("close", onClose);
+        };
+        stream.once("ready", onReady);
+        stream.once("close", onClose);
+        return;
+      }
+      const id = ++stream[kImpl].nextFlushId;
+      stream[kImpl].flushCallbacks.set(id, cb);
+      try {
+        stream.worker.postMessage({
+          code: "FLUSH",
+          context: "thread-stream",
+          id
+        });
+      } catch (err) {
+        stream[kImpl].flushCallbacks.delete(id);
+        destroy(stream, err);
+        process.nextTick(cb, err);
+      }
+    }
+    function failPendingFlushCallbacks(stream, err) {
+      const callbacks = stream[kImpl].flushCallbacks;
+      if (callbacks.size === 0) {
+        return;
+      }
+      const flushErr = err || new Error("the worker has exited");
+      for (const cb of callbacks.values()) {
+        process.nextTick(cb, flushErr);
+      }
+      callbacks.clear();
+    }
     function error(stream, err) {
       setImmediate(() => {
         stream.emit("error", err);
@@ -15263,6 +15291,7 @@ var require_thread_stream = __commonJS({
         return;
       }
       stream[kImpl].destroyed = true;
+      failPendingFlushCallbacks(stream, err);
       if (err) {
         stream[kImpl].errored = err;
         error(stream, err);
@@ -15280,12 +15309,37 @@ var require_thread_stream = __commonJS({
         });
       }
     }
-    function write(stream, data, cb) {
+    function write(stream, maxBytes, cb) {
       const current = Atomics.load(stream[kImpl].state, WRITE_INDEX);
-      const length = Buffer.byteLength(data);
-      stream[kImpl].data.write(data, current);
-      Atomics.store(stream[kImpl].state, WRITE_INDEX, current + length);
-      Atomics.notify(stream[kImpl].state, WRITE_INDEX);
+      let offset = current;
+      let remaining = maxBytes;
+      while (remaining > 0 && stream[kImpl].bufLen !== 0) {
+        const head = stream[kImpl].bufHead;
+        const buf = stream[kImpl].buf[head];
+        if (buf.length <= remaining) {
+          buf.copy(stream[kImpl].data, offset);
+          offset += buf.length;
+          remaining -= buf.length;
+          stream[kImpl].bufLen -= buf.length;
+          stream[kImpl].bufHead = head + 1;
+          if (stream[kImpl].bufHead === stream[kImpl].buf.length) {
+            stream[kImpl].buf.length = 0;
+            stream[kImpl].bufHead = 0;
+          } else if (stream[kImpl].bufHead >= 1024 && stream[kImpl].bufHead * 2 >= stream[kImpl].buf.length) {
+            stream[kImpl].buf.splice(0, stream[kImpl].bufHead);
+            stream[kImpl].bufHead = 0;
+          }
+          continue;
+        }
+        buf.copy(stream[kImpl].data, offset, 0, remaining);
+        stream[kImpl].buf[head] = buf.subarray(remaining);
+        stream[kImpl].bufLen -= remaining;
+        offset += remaining;
+        remaining = 0;
+      }
+      updateState(stream, () => {
+        Atomics.store(stream[kImpl].state, WRITE_INDEX, offset);
+      });
       cb();
       return true;
     }
@@ -15297,8 +15351,9 @@ var require_thread_stream = __commonJS({
       try {
         stream.flushSync();
         let readIndex = Atomics.load(stream[kImpl].state, READ_INDEX);
-        Atomics.store(stream[kImpl].state, WRITE_INDEX, -1);
-        Atomics.notify(stream[kImpl].state, WRITE_INDEX);
+        updateState(stream, () => {
+          Atomics.store(stream[kImpl].state, WRITE_INDEX, -1);
+        });
         let spins = 0;
         while (readIndex !== -1) {
           Atomics.wait(stream[kImpl].state, READ_INDEX, readIndex, 1e3);
@@ -15329,34 +15384,17 @@ var require_thread_stream = __commonJS({
         }
       };
       stream[kImpl].flushing = false;
-      while (stream[kImpl].buf.length !== 0) {
+      while (stream[kImpl].bufLen !== 0) {
         const writeIndex = Atomics.load(stream[kImpl].state, WRITE_INDEX);
-        let leftover = stream[kImpl].data.length - writeIndex;
+        const leftover = stream[kImpl].data.length - writeIndex;
         if (leftover === 0) {
           flushSync(stream);
-          Atomics.store(stream[kImpl].state, READ_INDEX, 0);
-          Atomics.store(stream[kImpl].state, WRITE_INDEX, 0);
+          resetIndexes(stream);
           continue;
         } else if (leftover < 0) {
           throw new Error("overwritten");
         }
-        let toWrite = stream[kImpl].buf.slice(0, leftover);
-        let toWriteBytes = Buffer.byteLength(toWrite);
-        if (toWriteBytes <= leftover) {
-          stream[kImpl].buf = stream[kImpl].buf.slice(leftover);
-          write(stream, toWrite, cb);
-        } else {
-          flushSync(stream);
-          Atomics.store(stream[kImpl].state, READ_INDEX, 0);
-          Atomics.store(stream[kImpl].state, WRITE_INDEX, 0);
-          while (toWriteBytes > stream[kImpl].buf.length) {
-            leftover = leftover / 2;
-            toWrite = stream[kImpl].buf.slice(0, leftover);
-            toWriteBytes = Buffer.byteLength(toWrite);
-          }
-          stream[kImpl].buf = stream[kImpl].buf.slice(leftover);
-          write(stream, toWrite, cb);
-        }
+        write(stream, leftover, cb);
       }
     }
     function flushSync(stream) {
@@ -15389,8 +15427,10 @@ var require_transport = __commonJS({
   "node_modules/pino/lib/transport.js"(exports2, module2) {
     "use strict";
     var { createRequire } = require("module");
+    var { existsSync } = require("fs");
     var getCallers = require_caller();
     var { join: join2, isAbsolute, sep } = require("path");
+    var { fileURLToPath } = require("url");
     var sleep = require_atomic_sleep();
     var onExit = require_on_exit_leak_free();
     var ThreadStream = require_thread_stream();
@@ -15401,11 +15441,101 @@ var require_transport = __commonJS({
         onExit.unregister(stream);
       });
     }
-    function buildStream(filename, workerData, workerOpts) {
+    function hasPreloadFlags() {
+      const execArgv = process.execArgv;
+      for (let i = 0; i < execArgv.length; i++) {
+        const arg = execArgv[i];
+        if (arg === "--import" || arg === "--require" || arg === "-r") {
+          return true;
+        }
+        if (arg.startsWith("--import=") || arg.startsWith("--require=") || arg.startsWith("-r=")) {
+          return true;
+        }
+      }
+      return false;
+    }
+    function sanitizeNodeOptions(nodeOptions) {
+      const tokens = nodeOptions.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g);
+      if (!tokens) {
+        return nodeOptions;
+      }
+      const sanitized = [];
+      let changed = false;
+      for (let i = 0; i < tokens.length; i++) {
+        const token2 = tokens[i];
+        if (token2 === "--require" || token2 === "-r" || token2 === "--import") {
+          const next = tokens[i + 1];
+          if (next && shouldDropPreload(next)) {
+            changed = true;
+            i++;
+            continue;
+          }
+          sanitized.push(token2);
+          if (next) {
+            sanitized.push(next);
+            i++;
+          }
+          continue;
+        }
+        if (token2.startsWith("--require=") || token2.startsWith("-r=") || token2.startsWith("--import=")) {
+          const value = token2.slice(token2.indexOf("=") + 1);
+          if (shouldDropPreload(value)) {
+            changed = true;
+            continue;
+          }
+        }
+        sanitized.push(token2);
+      }
+      return changed ? sanitized.join(" ") : nodeOptions;
+    }
+    function shouldDropPreload(value) {
+      const unquoted = stripQuotes(value);
+      if (!unquoted) {
+        return false;
+      }
+      let path = unquoted;
+      if (path.startsWith("file://")) {
+        try {
+          path = fileURLToPath(path);
+        } catch {
+          return false;
+        }
+      }
+      return isAbsolute(path) && !existsSync(path);
+    }
+    function stripQuotes(value) {
+      const first = value[0];
+      const last = value[value.length - 1];
+      if (first === '"' && last === '"' || first === "'" && last === "'") {
+        return value.slice(1, -1);
+      }
+      return value;
+    }
+    function buildStream(filename, workerData, workerOpts, sync, name) {
+      if (!workerOpts.execArgv && hasPreloadFlags() && require.main === void 0) {
+        workerOpts = {
+          ...workerOpts,
+          execArgv: []
+        };
+      }
+      if (!workerOpts.env && process.env.NODE_OPTIONS) {
+        const nodeOptions = sanitizeNodeOptions(process.env.NODE_OPTIONS);
+        if (nodeOptions !== process.env.NODE_OPTIONS) {
+          workerOpts = {
+            ...workerOpts,
+            env: {
+              ...process.env,
+              NODE_OPTIONS: nodeOptions
+            }
+          };
+        }
+      }
+      workerOpts = { ...workerOpts, name };
       const stream = new ThreadStream({
         filename,
         workerData,
-        workerOpts
+        workerOpts,
+        sync
       });
       stream.on("ready", onReady);
       stream.on("close", function() {
@@ -15441,29 +15571,42 @@ var require_transport = __commonJS({
       stream.flushSync();
     }
     function transport(fullOptions) {
-      const { pipeline, targets, levels, dedupe, options = {}, worker = {}, caller = getCallers() } = fullOptions;
+      const { pipeline, targets, levels, dedupe, worker = {}, caller = getCallers(), sync = false } = fullOptions;
+      const options = {
+        ...fullOptions.options
+      };
       const callers = typeof caller === "string" ? [caller] : caller;
-      const bundlerOverrides = "__bundlerPathsOverrides" in globalThis ? globalThis.__bundlerPathsOverrides : {};
+      const bundlerOverrides = typeof globalThis === "object" && Object.prototype.hasOwnProperty.call(globalThis, "__bundlerPathsOverrides") && globalThis.__bundlerPathsOverrides && typeof globalThis.__bundlerPathsOverrides === "object" ? globalThis.__bundlerPathsOverrides : /* @__PURE__ */ Object.create(null);
       let target = fullOptions.target;
       if (target && targets) {
         throw new Error("only one of target or targets can be specified");
       }
       if (targets) {
         target = bundlerOverrides["pino-worker"] || join2(__dirname, "worker.js");
-        options.targets = targets.map((dest) => {
+        options.targets = targets.filter((dest) => dest.target).map((dest) => {
           return {
             ...dest,
             target: fixTarget(dest.target)
           };
         });
+        options.pipelines = targets.filter((dest) => dest.pipeline).map((dest) => {
+          return dest.pipeline.map((t) => {
+            return {
+              ...t,
+              level: dest.level,
+              // duplicate the pipeline `level` property defined in the upper level
+              target: fixTarget(t.target)
+            };
+          });
+        });
       } else if (pipeline) {
-        target = bundlerOverrides["pino-pipeline-worker"] || join2(__dirname, "worker-pipeline.js");
-        options.targets = pipeline.map((dest) => {
+        target = bundlerOverrides["pino-worker"] || join2(__dirname, "worker.js");
+        options.pipelines = [pipeline.map((dest) => {
           return {
             ...dest,
             target: fixTarget(dest.target)
           };
-        });
+        })];
       }
       if (levels) {
         options.levels = levels;
@@ -15472,7 +15615,8 @@ var require_transport = __commonJS({
         options.dedupe = dedupe;
       }
       options.pinoWillSendConfig = true;
-      return buildStream(fixTarget(target), options, worker);
+      const name = targets || pipeline ? "pino.transport" : target;
+      return buildStream(fixTarget(target), options, worker, sync, name);
       function fixTarget(origin) {
         origin = bundlerOverrides[origin] || origin;
         if (isAbsolute(origin) || origin.indexOf("file://") === 0) {
@@ -15505,6 +15649,7 @@ var require_transport = __commonJS({
 var require_tools = __commonJS({
   "node_modules/pino/lib/tools.js"(exports2, module2) {
     "use strict";
+    var diagChan = require("diagnostics_channel");
     var format2 = require_quick_format_unescaped();
     var { mapHttpRequest, mapHttpResponse } = require_pino_std_serializers();
     var SonicBoom = require_sonic_boom();
@@ -15529,6 +15674,9 @@ var require_tools = __commonJS({
     } = require_symbols();
     var { isMainThread } = require("worker_threads");
     var transport = require_transport();
+    var [nodeMajor] = process.versions.node.split(".").map((v) => Number(v));
+    var asJsonChan = diagChan.tracingChannel("pino_asJson");
+    var asString = nodeMajor >= 25 ? (str) => JSON.stringify(str) : _asString;
     function noop() {
     }
     function genLog(level, hook) {
@@ -15566,7 +15714,7 @@ var require_tools = __commonJS({
         }
       }
     }
-    function asString(str) {
+    function _asString(str) {
       let result = "";
       let last = 0;
       let found = false;
@@ -15591,6 +15739,13 @@ var require_tools = __commonJS({
       return point < 32 ? JSON.stringify(str) : '"' + result + '"';
     }
     function asJson(obj, msg, num, time) {
+      if (asJsonChan.hasSubscribers === false) {
+        return _asJson.call(this, obj, msg, num, time);
+      }
+      const store = { instance: this, arguments };
+      return asJsonChan.traceSync(_asJson, store, this, obj, msg, num, time);
+    }
+    function _asJson(obj, msg, num, time) {
       const stringify2 = this[stringifySym];
       const stringifySafe = this[stringifySafeSym];
       const stringifiers = this[stringifiersSym];
@@ -15683,7 +15838,7 @@ var require_tools = __commonJS({
       bindings = formatter(bindings);
       for (const key in bindings) {
         value = bindings[key];
-        const valid = key !== "level" && key !== "serializers" && key !== "formatters" && key !== "customLevels" && bindings.hasOwnProperty(key) && value !== void 0;
+        const valid = (key.length < 5 || key !== "level" && key !== "serializers" && key !== "formatters" && key !== "customLevels") && bindings.hasOwnProperty(key) && value !== void 0;
         if (valid === true) {
           value = serializers[key] ? serializers[key](value) : value;
           value = (stringifiers[key] || wildcardStringifier || stringify2)(value, stringifySafe);
@@ -15696,11 +15851,10 @@ var require_tools = __commonJS({
     function hasBeenTampered(stream) {
       return stream.write !== stream.constructor.prototype.write;
     }
-    var hasNodeCodeCoverage = process.env.NODE_V8_COVERAGE || process.env.V8_COVERAGE;
     function buildSafeSonicBoom(opts) {
       const stream = new SonicBoom(opts);
       stream.on("error", filterBrokenPipe);
-      if (!hasNodeCodeCoverage && !opts.sync && isMainThread) {
+      if (!opts.sync && isMainThread) {
         onExit.register(stream, autoEnd);
         stream.on("close", function() {
           onExit.unregister(stream);
@@ -16040,7 +16194,7 @@ var require_levels2 = __commonJS({
 var require_meta = __commonJS({
   "node_modules/pino/lib/meta.js"(exports2, module2) {
     "use strict";
-    module2.exports = { version: "8.21.0" };
+    module2.exports = { version: "10.3.1" };
   }
 });
 
@@ -16055,7 +16209,6 @@ var require_proto = __commonJS({
       setLevelSym,
       getLevelSym,
       chindingsSym,
-      parsedChindingsSym,
       mixinSym,
       asJsonSym,
       writeSym,
@@ -16073,7 +16226,8 @@ var require_proto = __commonJS({
       stringifySym,
       formatOptsSym,
       stringifiersSym,
-      msgPrefixSym
+      msgPrefixSym,
+      hooksSym
     } = require_symbols();
     var {
       getLevel,
@@ -16088,7 +16242,8 @@ var require_proto = __commonJS({
       asChindings,
       asJson,
       buildFormatters,
-      stringify
+      stringify,
+      noop
     } = require_tools();
     var {
       version
@@ -16116,6 +16271,12 @@ var require_proto = __commonJS({
       set levelVal(n) {
         throw Error("levelVal is read-only");
       },
+      get msgPrefix() {
+        return this[msgPrefixSym];
+      },
+      get [Symbol.toStringTag]() {
+        return "Pino";
+      },
       [lsCacheSym]: initialLsCache,
       [writeSym]: write,
       [asJsonSym]: asJson,
@@ -16131,10 +16292,23 @@ var require_proto = __commonJS({
       if (!bindings2) {
         throw Error("missing bindings for child Pino");
       }
-      options = options || {};
       const serializers = this[serializersSym];
       const formatters = this[formattersSym];
       const instance = Object.create(this);
+      if (options == null) {
+        if (instance[formattersSym].bindings !== resetChildingsFormatter) {
+          instance[formattersSym] = buildFormatters(
+            formatters.level,
+            resetChildingsFormatter,
+            formatters.log
+          );
+        }
+        instance[chindingsSym] = asChindings(instance, bindings2);
+        if (this.onChild !== noop) {
+          this.onChild(instance);
+        }
+        return instance;
+      }
       if (options.hasOwnProperty("serializers") === true) {
         instance[serializersSym] = /* @__PURE__ */ Object.create(null);
         for (const k in serializers) {
@@ -16185,8 +16359,10 @@ var require_proto = __commonJS({
         instance[msgPrefixSym] = (this[msgPrefixSym] || "") + options.msgPrefix;
       }
       instance[chindingsSym] = asChindings(instance, bindings2);
-      const childLevel = options.level || this.level;
-      instance[setLevelSym](childLevel);
+      if (options.level !== void 0 && options.level !== this.level || options.hasOwnProperty("customLevels")) {
+        const childLevel = options.level || this.level;
+        instance[setLevelSym](childLevel);
+      }
       this.onChild(instance);
       return instance;
     }
@@ -16201,7 +16377,6 @@ var require_proto = __commonJS({
     function setBindings(newBindings) {
       const chindings = asChindings(this, newBindings);
       this[chindingsSym] = chindings;
-      delete this[parsedChindingsSym];
     }
     function defaultMixinMergeStrategy(mergeObject, mixinObject) {
       return Object.assign(mixinObject, mergeObject);
@@ -16213,6 +16388,7 @@ var require_proto = __commonJS({
       const messageKey = this[messageKeySym];
       const mixinMergeStrategy = this[mixinMergeStrategySym] || defaultMixinMergeStrategy;
       let obj;
+      const streamWriteHook = this[hooksSym].streamWrite;
       if (_obj === void 0 || _obj === null) {
         obj = {};
       } else if (_obj instanceof Error) {
@@ -16238,9 +16414,7 @@ var require_proto = __commonJS({
         stream.lastTime = t.slice(this[timeSliceIndexSym]);
         stream.lastLogger = this;
       }
-      stream.write(s);
-    }
-    function noop() {
+      stream.write(streamWriteHook ? streamWriteHook(s) : s);
     }
     function flush(cb) {
       if (cb != null && typeof cb !== "function") {
@@ -16262,7 +16436,6 @@ var require_multistream = __commonJS({
     var { DEFAULT_LEVELS } = require_constants();
     var DEFAULT_INFO_LEVEL = DEFAULT_LEVELS.info;
     function multistream(streamsArray, opts) {
-      let counter = 0;
       streamsArray = streamsArray || [];
       opts = opts || { dedupe: false };
       const streamLevels = Object.create(DEFAULT_LEVELS);
@@ -16275,10 +16448,12 @@ var require_multistream = __commonJS({
       const res = {
         write,
         add,
+        remove,
         emit,
         flushSync,
         end,
         minLevel: 0,
+        lastId: 0,
         streams: [],
         clone,
         [metadata]: true,
@@ -16359,13 +16534,23 @@ var require_multistream = __commonJS({
           stream: stream_,
           level,
           levelVal: void 0,
-          id: counter++
+          id: ++res.lastId
         };
         streams.unshift(dest_);
         streams.sort(compareByLevel);
         this.minLevel = streams[0].level;
         return res;
       }
+      function remove(id) {
+        const { streams } = this;
+        const index = streams.findIndex((s) => s.id === id);
+        if (index >= 0) {
+          streams.splice(index, 1);
+          streams.sort(compareByLevel);
+          this.minLevel = streams.length > 0 ? streams[0].level : -1;
+        }
+        return res;
+      }
       function end() {
         for (const { stream } of this.streams) {
           if (typeof stream.flushSync === "function") {
@@ -16385,6 +16570,7 @@ var require_multistream = __commonJS({
         return {
           write,
           add,
+          remove,
           minLevel: level,
           streams,
           clone,
@@ -16484,7 +16670,8 @@ var require_pino = __commonJS({
         }
       }),
       hooks: {
-        logMethod: void 0
+        logMethod: void 0,
+        streamWrite: void 0
       },
       timestamp: epochTime,
       name: void 0,
@@ -16499,6 +16686,7 @@ var require_pino = __commonJS({
     function pino(...args) {
       const instance = {};
       const { opts, stream } = normalize(instance, caller(), ...args);
+      if (opts.level && typeof opts.level === "string" && DEFAULT_LEVELS[opts.level.toLowerCase()] !== void 0) opts.level = opts.level.toLowerCase();
       const {
         redact,
         crlf,