@rife/logger 0.0.6-beta.16 → 0.0.6-beta.18

package/dist/cjs/trace.cjs

@@ -1,11 +1,15 @@
 "use strict";
 var __webpack_require__ = {};
 (()=>{
-    __webpack_require__.d = (exports1, definition)=>{
-        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-            enumerable: true,
-            get: definition[key]
-        });
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
     };
 })();
 (()=>{

package/dist/esm/common.mjs

@@ -1,7 +1,7 @@
 import "node:module";
 import path from "path";
 import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
-var common_filename = __rspack_fileURLToPath(import.meta.url);
-const isEsm = '.mjs' === path.extname(common_filename);
+var __rspack_import_meta_filename__ = __rspack_fileURLToPath(import.meta.url);
+const isEsm = '.mjs' === path.extname(__rspack_import_meta_filename__);
 const isCjs = !isEsm;
 export { isCjs, isEsm };

package/dist/esm/pino/index.mjs

@@ -5,17 +5,17 @@ import { genTraceId, getTraceId, runInTrace } from "../trace.mjs";
 import { __webpack_require__ } from "../rslib-runtime.mjs";
 import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
 import { dirname as __rspack_dirname } from "node:path";
-import * as __rspack_external_pino_std_serializers_719fa64c from "pino-std-serializers";
+var __rspack_import_meta_filename__ = __rspack_fileURLToPath(import.meta.url);
+var __rspack_import_meta_dirname__ = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
+import * as __rspack_external_pino_std_serializers_c7d9cf2d from "pino-std-serializers";
 __webpack_require__.add({
     "pino-std-serializers" (module) {
-        module.exports = __rspack_external_pino_std_serializers_719fa64c;
+        module.exports = __rspack_external_pino_std_serializers_c7d9cf2d;
     }
 });
-var pino_filename = __rspack_fileURLToPath(import.meta.url);
-var pino_dirname = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
 function getPinoConfig() {
     const targets = [];
-    const rotate = `./rotate${path.extname(pino_filename)}`;
+    const rotate = `./rotate${path.extname(__rspack_import_meta_filename__)}`;
     targets.push({
         level: 'debug',
         target: rotate,
@@ -24,11 +24,11 @@ function getPinoConfig() {
         }
     });
     if ("u" > typeof __isNodeSingleFileBundle || "u" > typeof __isVite || global?.__remix_devServerHooks || 'development' !== process.env.NODE_ENV) globalThis.__bundlerPathsOverrides = {
-        'pino-pretty': path.join(pino_dirname, './worker/pino-pretty.cjs'),
-        'pino-worker': path.join(pino_dirname, './worker/pino-worker.cjs'),
-        [rotate]: path.join(pino_dirname, './worker/pino-rotate.cjs'),
-        'pino/file': path.join(pino_dirname, './worker/pino-file.cjs'),
-        'thread-stream-worker': path.join(pino_dirname, './worker/thread-stream.cjs'),
+        'pino-pretty': path.join(__rspack_import_meta_dirname__, './worker/pino-pretty.cjs'),
+        'pino-worker': path.join(__rspack_import_meta_dirname__, './worker/pino-worker.cjs'),
+        [rotate]: path.join(__rspack_import_meta_dirname__, './worker/pino-rotate.cjs'),
+        'pino/file': path.join(__rspack_import_meta_dirname__, './worker/pino-file.cjs'),
+        'thread-stream-worker': path.join(__rspack_import_meta_dirname__, './worker/thread-stream.cjs'),
         ...globalThis.__bundlerPathsOverrides
     };
     'production' === process.env.NODE_ENV || void 0 !== process.env.VITEST || targets.push({

package/dist/esm/pino/rotate.mjs

@@ -1,9 +1,9 @@
 import "node:module";
 import { __webpack_require__ } from "../rslib-runtime.mjs";
-import * as __rspack_external_rotating_file_stream_66c5ea63 from "rotating-file-stream";
+import * as __rspack_external_rotating_file_stream_a9540b88 from "rotating-file-stream";
 __webpack_require__.add({
     "rotating-file-stream" (module) {
-        module.exports = __rspack_external_rotating_file_stream_66c5ea63;
+        module.exports = __rspack_external_rotating_file_stream_a9540b88;
     }
 });
 const generator = (time, index)=>{

package/dist/esm/pino/worker/pino-file.cjs

@@ -946,19 +946,32 @@ var __webpack_modules__ = {
             return stringify;
         }
     },
-    "../../node_modules/.pnpm/thread-stream@4.0.0/node_modules/thread-stream/index.js" (module1, __unused_rspack_exports, __webpack_require__) {
+    "../../node_modules/.pnpm/thread-stream@4.2.0/node_modules/thread-stream/index.js" (module1, __unused_rspack_exports, __webpack_require__) {
         "use strict";
-        const { version } = __webpack_require__("../../node_modules/.pnpm/thread-stream@4.0.0/node_modules/thread-stream/package.json");
+        const { version } = __webpack_require__("../../node_modules/.pnpm/thread-stream@4.2.0/node_modules/thread-stream/package.json");
         const { EventEmitter } = __webpack_require__("events");
         const { Worker } = __webpack_require__("worker_threads");
         const { join } = __webpack_require__("path");
         const { pathToFileURL } = __webpack_require__("url");
-        const { wait } = __webpack_require__("../../node_modules/.pnpm/thread-stream@4.0.0/node_modules/thread-stream/lib/wait.js");
-        const { WRITE_INDEX, READ_INDEX } = __webpack_require__("../../node_modules/.pnpm/thread-stream@4.0.0/node_modules/thread-stream/lib/indexes.js");
+        const { wait } = __webpack_require__("../../node_modules/.pnpm/thread-stream@4.2.0/node_modules/thread-stream/lib/wait.js");
+        const { WRITE_INDEX, READ_INDEX, SEQ_INDEX } = __webpack_require__("../../node_modules/.pnpm/thread-stream@4.2.0/node_modules/thread-stream/lib/indexes.js");
         const buffer = __webpack_require__("buffer");
         const assert = __webpack_require__("assert");
         const kImpl = Symbol('kImpl');
         const 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);
+            });
+        }
         class FakeWeakRef {
             constructor(value){
                 this._value = value;
@@ -983,6 +996,7 @@ var __webpack_modules__ = {
             const toExecute = bundlerOverrides['thread-stream-worker'] || join(__dirname, 'lib', 'worker.js');
             const worker = new Worker(toExecute, {
                 ...opts.workerOpts,
+                name: opts.workerOpts?.name || 'thread-stream',
                 trackUnmanagedFds: false,
                 workerData: {
                     filename: 0 === filename.indexOf('file://') ? filename : pathToFileURL(filename).href,
@@ -1010,42 +1024,31 @@ var __webpack_modules__ = {
             }
         }
         function nextFlush(stream) {
-            const writeIndex = Atomics.load(stream[kImpl].state, WRITE_INDEX);
-            let leftover = stream[kImpl].data.length - writeIndex;
-            if (leftover > 0) {
-                if (0 === stream[kImpl].buf.length) {
-                    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 (0 === stream[kImpl].bufLen) {
+                        stream[kImpl].flushing = false;
+                        if (stream[kImpl].ending) end(stream);
+                        else if (stream[kImpl].needDrain) process.nextTick(drain, stream);
+                        return;
+                    }
+                    write(stream, leftover, noop);
+                    continue;
+                }
+                if (0 === leftover) {
+                    if (0 === writeIndex && 0 === stream[kImpl].bufLen) return;
+                    waitForRead(stream, ()=>{
+                        if (stream.destroyed) return;
+                        resetIndexes(stream);
+                        nextFlush(stream);
+                    });
                     return;
                 }
-                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 (stream.destroyed) return;
-                    Atomics.store(stream[kImpl].state, READ_INDEX, 0);
-                    Atomics.store(stream[kImpl].state, WRITE_INDEX, 0);
-                    Atomics.notify(stream[kImpl].state, READ_INDEX);
-                    while(toWriteBytes > stream[kImpl].data.length){
-                        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));
-                });
-            } else if (0 === leftover) {
-                if (0 === writeIndex && 0 === stream[kImpl].buf.length) return;
-                stream.flush(()=>{
-                    Atomics.store(stream[kImpl].state, READ_INDEX, 0);
-                    Atomics.store(stream[kImpl].state, WRITE_INDEX, 0);
-                    Atomics.notify(stream[kImpl].state, READ_INDEX);
-                    nextFlush(stream);
-                });
-            } else destroy(stream, new Error('overwritten'));
+                destroy(stream, new Error('overwritten'));
+                return;
+            }
         }
         function onWorkerMessage(msg) {
             const stream = this.stream.deref();
@@ -1054,10 +1057,11 @@ var __webpack_modules__ = {
                 this.terminate();
                 return;
             }
+            if (msg?.code == null) return;
             switch(msg.code){
                 case 'READY':
                     this.stream = new WeakRef1(stream);
-                    stream.flush(()=>{
+                    waitForRead(stream, ()=>{
                         stream[kImpl].ready = true;
                         stream.emit('ready');
                     });
@@ -1069,6 +1073,19 @@ var __webpack_modules__ = {
                     if (Array.isArray(msg.args)) stream.emit(msg.name, ...msg.args);
                     else stream.emit(msg.name, msg.args);
                     break;
+                case 'FLUSHED':
+                    {
+                        if ('thread-stream' !== msg.context) {
+                            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;
@@ -1103,13 +1120,18 @@ var __webpack_modules__ = {
                 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 = 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;
@@ -1118,14 +1140,15 @@ var __webpack_modules__ = {
                     error(this, new Error('the worker is ending'));
                     return false;
                 }
-                if (this[kImpl].flushing && this[kImpl].buf.length + data.length >= MAX_STRING) try {
+                if (this[kImpl].flushing && this[kImpl].bufLen + dataBuf.length >= MAX_STRING) try {
                     writeSync(this);
                     this[kImpl].flushing = true;
                 } catch (err) {
                     destroy(this, err);
                     return false;
                 }
-                this[kImpl].buf += data;
+                this[kImpl].buf.push(dataBuf);
+                this[kImpl].bufLen += dataBuf.length;
                 if (this[kImpl].sync) try {
                     writeSync(this);
                     return true;
@@ -1137,7 +1160,7 @@ var __webpack_modules__ = {
                     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() {
@@ -1146,19 +1169,10 @@ var __webpack_modules__ = {
                 end(this);
             }
             flush(cb) {
-                if (this[kImpl].destroyed) {
-                    if ('function' == typeof cb) 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, 1 / 0, (err, res)=>{
-                    if (err) {
-                        destroy(this, err);
-                        process.nextTick(cb, err);
-                        return;
-                    }
-                    if ('not-equal' === res) return void this.flush(cb);
-                    process.nextTick(cb);
+                cb = 'function' == typeof cb ? cb : noop;
+                flushBuffer(this, (err)=>{
+                    if (err) return void process.nextTick(cb, err);
+                    requestWorkerFlush(this, cb);
                 });
             }
             flushSync() {
@@ -1200,6 +1214,63 @@ var __webpack_modules__ = {
                 return this[kImpl].errored;
             }
         }
+        function flushBuffer(stream, cb) {
+            if (stream[kImpl].destroyed) return void process.nextTick(cb, new Error('the worker has exited'));
+            if (!stream[kImpl].sync && (stream[kImpl].flushing || stream[kImpl].bufLen > 0)) return void setImmediate(flushBuffer, stream, cb);
+            waitForRead(stream, cb);
+        }
+        function waitForRead(stream, cb) {
+            const writeIndex = Atomics.load(stream[kImpl].state, WRITE_INDEX);
+            wait(stream[kImpl].state, READ_INDEX, writeIndex, 1 / 0, (err, res)=>{
+                if (err) {
+                    destroy(stream, err);
+                    cb(err);
+                    return;
+                }
+                if ('ok' !== res) return void waitForRead(stream, cb);
+                cb();
+            });
+        }
+        function requestWorkerFlush(stream, cb) {
+            if (stream[kImpl].destroyed) return void process.nextTick(cb, new Error('the worker has exited'));
+            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 (0 === callbacks.size) 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);
@@ -1208,6 +1279,7 @@ var __webpack_modules__ = {
         function destroy(stream, err) {
             if (stream[kImpl].destroyed) return;
             stream[kImpl].destroyed = true;
+            failPendingFlushCallbacks(stream, err);
             if (err) {
                 stream[kImpl].errored = err;
                 error(stream, err);
@@ -1221,12 +1293,37 @@ var __webpack_modules__ = {
                 stream.emit('close');
             });
         }
-        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 && 0 !== stream[kImpl].bufLen){
+                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 && 2 * stream[kImpl].bufHead >= 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;
         }
@@ -1236,8 +1333,9 @@ var __webpack_modules__ = {
             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(-1 !== readIndex){
                     Atomics.wait(stream[kImpl].state, READ_INDEX, readIndex, 1000);
@@ -1259,35 +1357,16 @@ var __webpack_modules__ = {
                 else if (stream[kImpl].needDrain) process.nextTick(drain, stream);
             };
             stream[kImpl].flushing = false;
-            while(0 !== stream[kImpl].buf.length){
+            while(0 !== stream[kImpl].bufLen){
                 const writeIndex = Atomics.load(stream[kImpl].state, WRITE_INDEX);
-                let leftover = stream[kImpl].data.length - writeIndex;
+                const leftover = stream[kImpl].data.length - writeIndex;
                 if (0 === leftover) {
                     flushSync(stream);
-                    Atomics.store(stream[kImpl].state, READ_INDEX, 0);
-                    Atomics.store(stream[kImpl].state, WRITE_INDEX, 0);
-                    Atomics.notify(stream[kImpl].state, READ_INDEX);
+                    resetIndexes(stream);
                     continue;
                 }
                 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);
-                    Atomics.notify(stream[kImpl].state, READ_INDEX);
-                    while(toWriteBytes > stream[kImpl].buf.length){
-                        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) {
@@ -1304,16 +1383,18 @@ var __webpack_modules__ = {
         }
         module1.exports = ThreadStream;
     },
-    "../../node_modules/.pnpm/thread-stream@4.0.0/node_modules/thread-stream/lib/indexes.js" (module1) {
+    "../../node_modules/.pnpm/thread-stream@4.2.0/node_modules/thread-stream/lib/indexes.js" (module1) {
         "use strict";
+        const SEQ_INDEX = 2;
         const WRITE_INDEX = 4;
         const READ_INDEX = 8;
         module1.exports = {
             WRITE_INDEX,
-            READ_INDEX
+            READ_INDEX,
+            SEQ_INDEX
         };
     },
-    "../../node_modules/.pnpm/thread-stream@4.0.0/node_modules/thread-stream/lib/wait.js" (module1) {
+    "../../node_modules/.pnpm/thread-stream@4.2.0/node_modules/thread-stream/lib/wait.js" (module1) {
         "use strict";
         const WAIT_MS = 10000;
         function wait(state, index, expected, timeout, done) {
@@ -1337,7 +1418,10 @@ var __webpack_modules__ = {
                 if (max !== 1 / 0 && Date.now() > max) return void done(null, 'timed-out');
                 const remaining = max === 1 / 0 ? 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(check);
+                if (result.async) result.value.then((res)=>{
+                    if ('ok' === res) return void done(null, 'ok');
+                    check();
+                });
                 else setImmediate(check);
             };
             check();
@@ -2668,7 +2752,7 @@ var __webpack_modules__ = {
         const { fileURLToPath } = __webpack_require__("node:url");
         const sleep = __webpack_require__("../../node_modules/.pnpm/atomic-sleep@1.0.0/node_modules/atomic-sleep/index.js");
         const onExit = __webpack_require__("../../node_modules/.pnpm/on-exit-leak-free@2.1.2/node_modules/on-exit-leak-free/index.js");
-        const ThreadStream = __webpack_require__("../../node_modules/.pnpm/thread-stream@4.0.0/node_modules/thread-stream/index.js");
+        const ThreadStream = __webpack_require__("../../node_modules/.pnpm/thread-stream@4.2.0/node_modules/thread-stream/index.js");
         function setupOnExit(stream) {
             onExit.register(stream, autoEnd);
             onExit.registerBeforeExit(stream, flush);
@@ -3432,10 +3516,10 @@ var __webpack_modules__ = {
         SonicBoom.default = SonicBoom;
         module1.exports = SonicBoom;
     },
-    "../../node_modules/.pnpm/thread-stream@4.0.0/node_modules/thread-stream/package.json" (module1) {
+    "../../node_modules/.pnpm/thread-stream@4.2.0/node_modules/thread-stream/package.json" (module1) {
         "use strict";
         module1.exports = {
-            version: "4.0.0"
+            version: "4.2.0"
         };
     }
 };

package/dist/esm/pino/worker/pino-pretty.cjs

@@ -1127,7 +1127,7 @@ var __webpack_modules__ = {
         exports.createColors = createColors;
         exports.isColorSupported = isColorSupported;
     },
-    "../../node_modules/.pnpm/fast-copy@4.0.3/node_modules/fast-copy/dist/cjs/index.cjs" (__unused_rspack_module, exports) {
+    "../../node_modules/.pnpm/fast-copy@4.0.4/node_modules/fast-copy/dist/cjs/index.cjs" (__unused_rspack_module, exports) {
         "use strict";
         const toStringFunction = Function.prototype.toString;
         const toStringObject = Object.prototype.toString;
@@ -1146,7 +1146,7 @@ var __webpack_modules__ = {
             const type = toStringObject.call(value);
             return type.substring(8, type.length - 1);
         }
-        const { hasOwnProperty, propertyIsEnumerable } = Object.prototype;
+        const { propertyIsEnumerable } = Object.prototype;
         function copyOwnDescriptor(original, clone, property, state) {
             const ownDescriptor = Object.getOwnPropertyDescriptor(original, property) || {
                 configurable: true,
@@ -1167,10 +1167,8 @@ var __webpack_modules__ = {
             }
         }
         function copyOwnPropertiesStrict(value, clone, state) {
-            const names = Object.getOwnPropertyNames(value);
-            for(let index = 0; index < names.length; ++index)copyOwnDescriptor(value, clone, names[index], state);
-            const symbols = Object.getOwnPropertySymbols(value);
-            for(let index = 0; index < symbols.length; ++index)copyOwnDescriptor(value, clone, symbols[index], state);
+            for (const name of Object.getOwnPropertyNames(value))copyOwnDescriptor(value, clone, name, state);
+            for (const symbol of Object.getOwnPropertySymbols(value))copyOwnDescriptor(value, clone, symbol, state);
             return clone;
         }
         function copyArrayLoose(array, state) {
@@ -1199,9 +1197,7 @@ var __webpack_modules__ = {
         function copyMapLoose(map, state) {
             const clone = new state.Constructor();
             state.cache.set(map, clone);
-            map.forEach((value, key)=>{
-                clone.set(key, state.copier(value, state));
-            });
+            for (const [key, value] of map)clone.set(key, state.copier(value, state));
             return clone;
         }
         function copyMapStrict(map, state) {
@@ -1210,12 +1206,8 @@ var __webpack_modules__ = {
         function copyObjectLoose(object, state) {
             const clone = getCleanClone(state.prototype);
             state.cache.set(object, clone);
-            for(const key in object)if (hasOwnProperty.call(object, key)) clone[key] = state.copier(object[key], state);
-            const symbols = Object.getOwnPropertySymbols(object);
-            for(let index = 0; index < symbols.length; ++index){
-                const symbol = symbols[index];
-                if (propertyIsEnumerable.call(object, symbol)) clone[symbol] = state.copier(object[symbol], state);
-            }
+            for (const key of Object.keys(object))clone[key] = state.copier(object[key], state);
+            for (const symbol of Object.getOwnPropertySymbols(object))if (propertyIsEnumerable.call(object, symbol)) clone[symbol] = state.copier(object[symbol], state);
             return clone;
         }
         function copyObjectStrict(object, state) {
@@ -1237,9 +1229,7 @@ var __webpack_modules__ = {
         function copySetLoose(set, state) {
             const clone = new state.Constructor();
             state.cache.set(set, clone);
-            set.forEach((value)=>{
-                clone.add(state.copier(value, state));
-            });
+            for (const value of set)clone.add(state.copier(value, state));
             return clone;
         }
         function copySetStrict(set, state) {
@@ -1732,7 +1722,7 @@ var __webpack_modules__ = {
     "../../node_modules/.pnpm/pino-pretty@13.1.3/node_modules/pino-pretty/lib/utils/filter-log.js" (module1, __unused_rspack_exports, __webpack_require__) {
         "use strict";
         module1.exports = filterLog;
-        const { createCopier } = __webpack_require__("../../node_modules/.pnpm/fast-copy@4.0.3/node_modules/fast-copy/dist/cjs/index.cjs");
+        const { createCopier } = __webpack_require__("../../node_modules/.pnpm/fast-copy@4.0.4/node_modules/fast-copy/dist/cjs/index.cjs");
         const fastCopy = createCopier({});
         const deleteLogProperty = __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.3/node_modules/pino-pretty/lib/utils/delete-log-property.js");
         function filterLog({ log, context }) {

package/dist/esm/pino/worker/pino-rotate.cjs

@@ -554,11 +554,15 @@ function __webpack_require__(moduleId) {
     return module1.exports;
 }
 (()=>{
-    __webpack_require__.d = (exports, definition)=>{
-        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) Object.defineProperty(exports, key, {
-            enumerable: true,
-            get: definition[key]
-        });
+    __webpack_require__.d = (exports, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports, key)) Object.defineProperty(exports, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
     };
 })();
 (()=>{
@@ -577,9 +581,6 @@ function __webpack_require__(moduleId) {
 var __webpack_exports__ = {};
 (()=>{
     __webpack_require__.r(__webpack_exports__);
-    __webpack_require__.d(__webpack_exports__, {
-        default: ()=>__rspack_default_export
-    });
     const generator = (time, index)=>{
         if (!time) return 'server.log';
         time = new Date(time);
@@ -601,5 +602,8 @@ var __webpack_exports__ = {};
             path
         });
     };
+    __webpack_require__.d(__webpack_exports__, {}, {
+        default: __rspack_default_export
+    });
 })();
 module.exports = __webpack_exports__;