@zuplo/cli 6.69.9 → 6.69.11

package/node_modules/pino-http/node_modules/thread-stream/node_modules/real-require/README.md

@@ -0,0 +1,51 @@
+# real-require
+
+Keep require and import consistent after bundling or transpiling.
+
+## Installation
+
+Just run:
+
+```bash
+npm install real-require
+```
+
+## Usage
+
+The package provides two drop-ins functions, `realRequire` and `realImport`,
+which can be used in scenarios where tools like transpilers or bundlers change
+the native `require` or `await import` calls.
+
+The current `realRequire` functions only handles webpack at the moment, wrapping
+the `__non_webpack__require__` implementation that webpack provides for the
+final bundle.
+
+### Example
+
+```js
+// After bundling, real-require will be embedded in the bundle
+const { realImport, realRequire } = require('real-require')
+
+/*
+  By using realRequire, at build time the module will not be embedded and at runtime it will try to load path from the local filesytem.
+  This is useful in situations where the build tool does not support skipping modules to embed.
+*/
+const { join } = realRequire('path')
+
+async function main() {
+  // Similarly, this make sure the import call is not modified by the build tools
+  const localFunction = await realImport('./source.js')
+
+  localFunction()
+}
+
+main().catch(console.error)
+```
+
+## Contributing
+
+See [CONTRIBUTING.md](./CONTRIBUTING.md)
+
+## License
+
+Copyright Paolo Insogna and real-require contributors 2021. Licensed under the [MIT License](http://www.apache.org/licenses/MIT).

package/node_modules/pino-http/node_modules/thread-stream/node_modules/real-require/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "real-require",
+  "version": "1.0.0",
+  "description": "Keep require and import consistent after bundling or transpiling",
+  "author": "Paolo Insogna <shogun@cowtech.it>",
+  "homepage": "https://github.com/pinojs/real-require",
+  "contributors": [
+    {
+      "name": "Paolo Insogna",
+      "url": "https://github.com/ShogunPanda"
+    }
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pinojs/real-require.git"
+  },
+  "bugs": {
+    "url": "https://github.com/pinojs/real-require/issues"
+  },
+  "main": "src/index.js",
+  "files": [
+    "src"
+  ],
+  "scripts": {
+    "lint": "eslint .",
+    "lint:fix": "eslint --fix .",
+    "test": "c8 --reporter=text --reporter=html borp 'test/*.test.js'",
+    "test:ci": "c8 --reporter=text --reporter=json --check-coverage --branches 90 --functions 90 --lines 90 --statements 90 borp 'test/*.test.js'",
+    "ci": "npm run lint && npm run test:ci"
+  },
+  "devDependencies": {
+    "borp": "^1.0.0",
+    "c8": "^8.0.0",
+    "eslint": "^9.39.4",
+    "neostandard": "^0.13.0"
+  }
+}

package/node_modules/pino-http/node_modules/thread-stream/node_modules/real-require/src/index.js

@@ -0,0 +1,14 @@
+/* eslint-disable no-new-func */
+/* globals __non_webpack__require__ */
+
+const realImport = new Function('modulePath', 'return import(modulePath)')
+
+function realRequire (modulePath) {
+  if (typeof __non_webpack__require__ === 'function') {
+    return __non_webpack__require__(modulePath)
+  }
+
+  return require(modulePath)
+}
+
+module.exports = { realImport, realRequire }

package/node_modules/pino-http/node_modules/thread-stream/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thread-stream",
-  "version": "4.0.0",
+  "version": "4.1.0",
   "description": "A streaming way to send data to a Node.js Worker Thread",
   "main": "index.js",
   "types": "index.d.ts",
@@ -8,30 +8,28 @@
     "node": ">=20"
   },
   "dependencies": {
-    "real-require": "^0.2.0"
+    "real-require": "^1.0.0"
   },
   "devDependencies": {
-    "@types/node": "^22.0.0",
+    "@types/node": "^25.0.2",
     "@yao-pkg/pkg": "^6.0.0",
-    "borp": "^0.21.0",
+    "borp": "^1.0.0",
     "desm": "^1.3.0",
     "eslint": "^9.39.1",
     "fastbench": "^1.0.1",
-    "husky": "^9.0.6",
-    "neostandard": "^0.12.2",
+    "neostandard": "^0.13.0",
     "pino-elasticsearch": "^8.0.0",
-    "sonic-boom": "^4.0.1",
+    "sonic-boom": "^5.0.0",
     "ts-node": "^10.8.0",
     "typescript": "~5.7.3"
   },
   "scripts": {
     "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",
-    "prepare": "husky install"
+    "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",

package/node_modules/pino-http/node_modules/thread-stream/test/flush-worker.js

@@ -0,0 +1,68 @@
+'use strict'
+
+const { EventEmitter } = require('events')
+const { parentPort } = require('worker_threads')
+
+function createDestination (mode) {
+  const destination = new EventEmitter()
+  destination.writableEnded = false
+  destination.writableNeedDrain = false
+
+  destination.write = function () {
+    if (mode === 'drain') {
+      destination.writableNeedDrain = true
+      setTimeout(() => {
+        destination.writableNeedDrain = false
+        parentPort.postMessage({
+          code: 'EVENT',
+          name: 'destination-drain'
+        })
+        destination.emit('drain')
+      }, 50)
+    }
+
+    return true
+  }
+
+  destination.end = function () {
+    destination.writableEnded = true
+    destination.emit('close')
+  }
+
+  if (mode === 'flush') {
+    destination.flush = function (cb) {
+      setTimeout(() => {
+        parentPort.postMessage({
+          code: 'EVENT',
+          name: 'destination-flushed'
+        })
+        cb()
+      }, 50)
+    }
+  }
+
+  if (mode === 'flush-sync') {
+    destination.flushSync = function () {
+      parentPort.postMessage({
+        code: 'EVENT',
+        name: 'destination-flush-sync'
+      })
+    }
+  }
+
+  if (mode === 'exit-on-flush') {
+    destination.flush = function (_cb) {
+      setTimeout(() => {
+        process.exit(0)
+      }, 20)
+    }
+  }
+
+  return destination
+}
+
+async function run (opts) {
+  return createDestination(opts.mode)
+}
+
+module.exports = run

package/node_modules/pino-http/node_modules/thread-stream/test/flush.test.js

@@ -0,0 +1,112 @@
+'use strict'
+
+const { test } = require('node:test')
+const assert = require('node:assert')
+const { once } = require('node:events')
+const { join } = require('node:path')
+const ThreadStream = require('..')
+
+function createStream (mode) {
+  return new ThreadStream({
+    filename: join(__dirname, 'flush-worker.js'),
+    workerData: { mode },
+    sync: false
+  })
+}
+
+test('flush waits for worker destination.flush(cb)', async function () {
+  const stream = createStream('flush')
+  let flushed = false
+
+  stream.on('destination-flushed', () => {
+    flushed = true
+  })
+
+  assert.ok(stream.write('hello'))
+
+  await new Promise((resolve, reject) => {
+    stream.flush((err) => {
+      if (err) {
+        reject(err)
+        return
+      }
+      resolve()
+    })
+  })
+
+  assert.strictEqual(flushed, true)
+
+  const close = once(stream, 'close')
+  stream.end()
+  await close
+})
+
+test('flush falls back to destination.flushSync()', async function () {
+  const stream = createStream('flush-sync')
+  let called = false
+
+  stream.on('destination-flush-sync', () => {
+    called = true
+  })
+
+  assert.ok(stream.write('hello'))
+
+  await new Promise((resolve, reject) => {
+    stream.flush((err) => {
+      if (err) {
+        reject(err)
+        return
+      }
+      resolve()
+    })
+  })
+
+  assert.strictEqual(called, true)
+
+  const close = once(stream, 'close')
+  stream.end()
+  await close
+})
+
+test('flush waits for drain when destination has no flush API', async function () {
+  const stream = createStream('drain')
+  let drained = false
+
+  stream.on('destination-drain', () => {
+    drained = true
+  })
+
+  assert.ok(stream.write('hello'))
+
+  await new Promise((resolve, reject) => {
+    stream.flush((err) => {
+      if (err) {
+        reject(err)
+        return
+      }
+      resolve()
+    })
+  })
+
+  assert.strictEqual(drained, true)
+
+  const close = once(stream, 'close')
+  stream.end()
+  await close
+})
+
+test('pending flush callbacks fail when worker exits', async function () {
+  const stream = createStream('exit-on-flush')
+  const close = once(stream, 'close')
+
+  assert.ok(stream.write('hello'))
+
+  const err = await new Promise((resolve) => {
+    stream.flush(resolve)
+  })
+
+  assert.ok(err)
+  assert.strictEqual(err.message, 'the worker has exited')
+
+  await close
+})

package/node_modules/pino-http/node_modules/thread-stream/test/message-without-code.js

@@ -0,0 +1,19 @@
+'use strict'
+
+const { Writable } = require('stream')
+const { parentPort } = require('worker_threads')
+
+async function run () {
+  parentPort.postMessage({
+    internal: 'watch-mode'
+  })
+
+  return new Writable({
+    autoDestroy: true,
+    write (chunk, enc, cb) {
+      cb()
+    }
+  })
+}
+
+module.exports = run

package/node_modules/pino-http/node_modules/thread-stream/test/report-thread-name.js

@@ -0,0 +1,16 @@
+'use strict'
+
+const { Writable } = require('stream')
+const { threadName, parentPort } = require('worker_threads')
+
+module.exports = function () {
+  parentPort.once('message', function ({ port }) {
+    port.postMessage({ threadName })
+  })
+
+  return new Writable({
+    write (chunk, encoding, callback) {
+      callback()
+    }
+  })
+}

package/node_modules/pino-http/node_modules/thread-stream/test/thread-management.test.js

@@ -27,6 +27,9 @@ test('emit error if thread exits', async function (t) {
   })
 
   const closed = once(stream, 'close').catch(() => {})
+  // Keep a persistent error listener to avoid unhandled late error events
+  // reported as asynchronous activity by stricter test runners.
+  stream.on('error', () => {})
 
   stream.on('ready', () => {
     stream.write('hello world\n')
@@ -53,6 +56,9 @@ test('emit error if thread have unhandledRejection', async function (t) {
   })
 
   const closed = once(stream, 'close').catch(() => {})
+  // Keep a persistent error listener to avoid unhandled late error events
+  // reported as asynchronous activity by stricter test runners.
+  stream.on('error', () => {})
 
   stream.on('ready', () => {
     stream.write('hello world\n')
@@ -79,6 +85,9 @@ test('emit error if worker stream emit error', async function (t) {
   })
 
   const closed = once(stream, 'close').catch(() => {})
+  // Keep a persistent error listener to avoid unhandled late error events
+  // reported as asynchronous activity by stricter test runners.
+  stream.on('error', () => {})
 
   stream.on('ready', () => {
     stream.write('hello world\n')
@@ -105,6 +114,9 @@ test('emit error if thread have uncaughtException', async function (t) {
   })
 
   const closed = once(stream, 'close').catch(() => {})
+  // Keep a persistent error listener to avoid unhandled late error events
+  // reported as asynchronous activity by stricter test runners.
+  stream.on('error', () => {})
 
   stream.on('ready', () => {
     stream.write('hello world\n')

package/node_modules/pino-http/node_modules/thread-stream/test/watch-mode.test.js

@@ -0,0 +1,30 @@
+'use strict'
+
+const { test } = require('node:test')
+const assert = require('node:assert')
+const { once } = require('events')
+const { join } = require('path')
+const ThreadStream = require('..')
+
+test('ignores worker messages without a protocol code', async function () {
+  const stream = new ThreadStream({
+    filename: join(__dirname, 'message-without-code.js'),
+    sync: false
+  })
+
+  const errors = []
+  stream.on('error', err => {
+    errors.push(err)
+  })
+
+  const ready = once(stream, 'ready')
+  const close = once(stream, 'close')
+
+  assert.ok(stream.write('hello world\n'))
+  stream.end()
+
+  await ready
+  await close
+
+  assert.deepStrictEqual(errors, [])
+})

package/node_modules/pino-http/node_modules/thread-stream/test/worker-name.test.js

@@ -0,0 +1,43 @@
+'use strict'
+
+const { test } = require('node:test')
+const assert = require('node:assert')
+const { join } = require('path')
+const { once } = require('events')
+const { MessageChannel } = require('worker_threads')
+const ThreadStream = require('..')
+
+// threadName was added in Node.js v22.20.0 and v24.6.0
+const [major, minor] = process.versions.node.split('.').map(Number)
+const supportsThreadName = (major === 22 && minor >= 20) || major >= 24
+
+test('worker has default name "thread-stream"', { skip: !supportsThreadName }, async function (t) {
+  const { port1, port2 } = new MessageChannel()
+  const stream = new ThreadStream({
+    filename: join(__dirname, 'report-thread-name.js'),
+    sync: true
+  })
+
+  t.after(() => stream.end())
+
+  stream.emit('message', { port: port1 }, [port1])
+  const [{ threadName }] = await once(port2, 'message')
+  assert.strictEqual(threadName, 'thread-stream')
+})
+
+test('worker name can be overridden via workerOpts', { skip: !supportsThreadName }, async function (t) {
+  const { port1, port2 } = new MessageChannel()
+  const stream = new ThreadStream({
+    filename: join(__dirname, 'report-thread-name.js'),
+    workerOpts: {
+      name: 'my-custom-worker'
+    },
+    sync: true
+  })
+
+  t.after(() => stream.end())
+
+  stream.emit('message', { port: port1 }, [port1])
+  const [{ threadName }] = await once(port2, 'message')
+  assert.strictEqual(threadName, 'my-custom-worker')
+})

package/node_modules/protobufjs/dist/light/protobuf.js

@@ -1,6 +1,6 @@
 /*!
- * protobuf.js v7.5.6 (c) 2016, daniel wirtz
- * compiled tue, 28 apr 2026 00:45:19 utc
+ * protobuf.js v7.5.7 (c) 2016, daniel wirtz
+ * compiled sat, 09 may 2026 05:45:39 utc
  * licensed under the bsd-3-clause license
  * see: https://github.com/dcodeio/protobuf.js for details
  */
@@ -3422,8 +3422,10 @@ Namespace.prototype._lookupImpl = function lookup(path, flatPath) {
     // Otherwise try each nested namespace
     } else {
         for (var i = 0; i < this.nestedArray.length; ++i)
-            if (this._nestedArray[i] instanceof Namespace && (found = this._nestedArray[i]._lookupImpl(path, flatPath)))
+            if (this._nestedArray[i] instanceof Namespace && (found = this._nestedArray[i]._lookupImpl(path, flatPath))) {
                 exact = found;
+                break;
+            }
     }
 
     // Set this even when null, so that when we walk up the tree we can quickly bail on repeated checks back down.