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

package/dist/cjs/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__;

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

@@ -1151,19 +1151,32 @@ var __webpack_modules__ = {
         }
         module1.exports = split;
     },
-    "../../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;
@@ -1188,6 +1201,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,
@@ -1215,42 +1229,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();
@@ -1259,10 +1262,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');
                     });
@@ -1274,6 +1278,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;
@@ -1308,13 +1325,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;
@@ -1323,14 +1345,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;
@@ -1342,7 +1365,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() {
@@ -1351,19 +1374,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() {
@@ -1405,6 +1419,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);
@@ -1413,6 +1484,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);
@@ -1426,12 +1498,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;
         }
@@ -1441,8 +1538,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);
@@ -1464,35 +1562,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) {
@@ -1509,16 +1588,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) {
@@ -1542,7 +1623,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();
@@ -2898,7 +2982,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);
@@ -3745,10 +3829,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/cjs/pino/worker/thread-stream.cjs

@@ -1,6 +1,6 @@
 "use strict";
 var __webpack_modules__ = {
-    "../../node_modules/.pnpm/real-require@0.2.0/node_modules/real-require/src/index.js" (module1) {
+    "../../node_modules/.pnpm/real-require@1.0.0/node_modules/real-require/src/index.js" (module1) {
         const realImport = new Function('modulePath', 'return import(modulePath)');
         function realRequire(modulePath) {
             if ('function' == typeof __non_webpack__require__) return __non_webpack__require__(modulePath);
@@ -11,16 +11,18 @@ var __webpack_modules__ = {
             realRequire
         };
     },
-    "../../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) {
@@ -44,7 +46,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();
@@ -54,6 +59,10 @@ var __webpack_modules__ = {
             waitDiff
         };
     },
+    string_decoder (module1) {
+        "use strict";
+        module1.exports = require("string_decoder");
+    },
     worker_threads (module1) {
         "use strict";
         module1.exports = require("worker_threads");
@@ -72,15 +81,81 @@ function __webpack_require__(moduleId) {
 var __webpack_exports__ = {};
 (()=>{
     "use strict";
-    const { realImport, realRequire } = __webpack_require__("../../node_modules/.pnpm/real-require@0.2.0/node_modules/real-require/src/index.js");
+    const { realImport, realRequire } = __webpack_require__("../../node_modules/.pnpm/real-require@1.0.0/node_modules/real-require/src/index.js");
     const { workerData, parentPort } = __webpack_require__("worker_threads");
-    const { WRITE_INDEX, READ_INDEX } = __webpack_require__("../../node_modules/.pnpm/thread-stream@4.0.0/node_modules/thread-stream/lib/indexes.js");
-    const { waitDiff } = __webpack_require__("../../node_modules/.pnpm/thread-stream@4.0.0/node_modules/thread-stream/lib/wait.js");
+    const { StringDecoder } = __webpack_require__("string_decoder");
+    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 { waitDiff } = __webpack_require__("../../node_modules/.pnpm/thread-stream@4.2.0/node_modules/thread-stream/lib/wait.js");
     const { dataBuf, filename, stateBuf } = workerData;
     let destination;
+    const flushQueue = [];
+    let flushing = false;
     const state = new Int32Array(stateBuf);
     const data = Buffer.from(dataBuf);
+    const decoder = new StringDecoder('utf8');
     const keepAlive = setInterval(()=>{}, 3600000);
+    function onParentPortMessage(msg) {
+        if (!msg || 'FLUSH' !== msg.code || 'thread-stream' !== msg.context) return;
+        flushQueue.push(msg.id);
+        processFlushQueue();
+    }
+    function processFlushQueue() {
+        if (flushing || !destination) return;
+        const id = flushQueue.shift();
+        if (void 0 === id) return;
+        flushing = true;
+        flushDestination((err)=>{
+            flushing = false;
+            if (err) return void parentPort.postMessage({
+                code: 'ERROR',
+                err
+            });
+            parentPort.postMessage({
+                code: 'FLUSHED',
+                context: 'thread-stream',
+                id
+            });
+            processFlushQueue();
+        });
+    }
+    function flushDestination(cb) {
+        if ('function' == typeof destination?.flush) {
+            if (0 === destination.flush.length) {
+                try {
+                    const result = destination.flush();
+                    if (result && 'function' == typeof result.then) result.then(()=>cb(), cb);
+                    else cb();
+                } catch (err) {
+                    cb(err);
+                }
+                return;
+            }
+            let done = false;
+            const onDone = (err)=>{
+                if (done) return;
+                done = true;
+                cb(err);
+            };
+            try {
+                const result = destination.flush(onDone);
+                if (result && 'function' == typeof result.then) result.then(()=>onDone(), onDone);
+            } catch (err) {
+                onDone(err);
+            }
+            return;
+        }
+        if ('function' == typeof destination?.flushSync) {
+            try {
+                destination.flushSync();
+                cb();
+            } catch (err) {
+                cb(err);
+            }
+            return;
+        }
+        if (destination?.writableNeedDrain && !destination?.writableEnded) return void destination.once('drain', cb);
+        cb();
+    }
     async function start() {
         let worker;
         try {
@@ -124,19 +199,38 @@ var __webpack_exports__ = {};
                 process.exit(0);
             });
         });
+        processFlushQueue();
     }
     start().then(function() {
+        parentPort.on('message', onParentPortMessage);
         parentPort.postMessage({
             code: 'READY'
         });
         process.nextTick(run);
     });
+    function readState() {
+        while(true){
+            const seq = Atomics.load(state, SEQ_INDEX);
+            if ((1 & seq) !== 0) continue;
+            const current = Atomics.load(state, READ_INDEX);
+            const end = Atomics.load(state, WRITE_INDEX);
+            if (seq === Atomics.load(state, SEQ_INDEX)) return {
+                current,
+                end,
+                seq
+            };
+        }
+    }
     function run() {
-        const current = Atomics.load(state, READ_INDEX);
-        const end = Atomics.load(state, WRITE_INDEX);
-        if (end === current) return void (end === data.length ? waitDiff(state, READ_INDEX, end, 1 / 0, run) : waitDiff(state, WRITE_INDEX, end, 1 / 0, run));
-        if (-1 === end) return void destination.end();
-        const toWrite = data.toString('utf8', current, end);
+        const { current, end, seq } = readState();
+        if (end === current) return void waitDiff(state, SEQ_INDEX, seq, 1 / 0, run);
+        if (-1 === end) {
+            const remaining = decoder.end();
+            if (remaining.length > 0) destination.write(remaining);
+            destination.end();
+            return;
+        }
+        const toWrite = decoder.write(data.subarray(current, end));
         const res = destination.write(toWrite);
         if (res) {
             Atomics.store(state, READ_INDEX, end);