@contrail/cli 3.4.5 → 3.4.6-alpha.cffb28e

package/node_modules/thread-stream/CLAUDE.md

@@ -0,0 +1,53 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Build & Test Commands
+
+```sh
+npm test                    # Run linter (standard), type check, transpile, and all tests
+npm run build               # Type check only (tsc --noEmit)
+npm run transpile           # Generate transpiled test files for various ES targets
+
+# Run a single test file
+npx tap test/base.test.js
+
+# Run only JavaScript tests (faster)
+npx tap "test/**/*.test.*js"
+
+# Run only TypeScript tests
+npx tap --ts test/*.test.*ts
+```
+
+## Code Style
+
+This project uses [Standard](https://standardjs.com/) for linting. No semicolons, 2-space indentation.
+
+## Architecture
+
+thread-stream is a library for streaming data to a Node.js Worker Thread using SharedArrayBuffer for high-performance inter-thread communication.
+
+### Core Components
+
+- **index.js** - Main `ThreadStream` class extending EventEmitter. Manages the worker lifecycle, handles writes via SharedArrayBuffer, and coordinates synchronization using Atomics.
+
+- **lib/worker.js** - Runs in the Worker Thread. Loads the user-provided destination module, reads data from SharedArrayBuffer, and writes to the destination stream. Handles both ESM and CommonJS modules, including yarn PnP compatibility.
+
+- **lib/indexes.js** - Defines SharedArrayBuffer index constants (`WRITE_INDEX`, `READ_INDEX`) used for Atomics coordination.
+
+- **lib/wait.js** - Async polling utilities (`wait`, `waitDiff`) for cross-thread synchronization without blocking the main thread.
+
+### Data Flow
+
+1. Main thread writes strings to an internal buffer, then copies to SharedArrayBuffer
+2. Atomics.notify signals the worker that data is available
+3. Worker reads from SharedArrayBuffer via Atomics.load and writes to destination stream
+4. Worker updates READ_INDEX and notifies main thread when done
+5. Special index values (-1 for end, -2 for error) signal stream termination
+
+### Key Features
+
+- **Sync/async modes** - `sync: true` blocks until data is written; async mode uses `setImmediate` batching
+- **Backpressure** - Handles `drain` events from destination streams
+- **GC cleanup** - Uses FinalizationRegistry to terminate orphaned workers
+- **TypeScript support** - Workers can be `.ts` files (requires ts-node)

package/node_modules/thread-stream/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Matteo Collina
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/node_modules/thread-stream/README.md

@@ -0,0 +1,135 @@
+# thread-stream
+[![npm version](https://img.shields.io/npm/v/thread-stream)](https://www.npmjs.com/package/thread-stream)
+[![Build Status](https://img.shields.io/github/actions/workflow/status/pinojs/thread-stream/ci.yml?branch=main)](https://github.com/pinojs/thread-stream/actions)
+[![js-standard-style](https://img.shields.io/badge/code%20style-standard-brightgreen.svg?style=flat)](https://standardjs.com/)
+
+A streaming way to send data to a Node.js Worker Thread.
+
+## install
+
+```sh
+npm i thread-stream
+```
+
+## Usage
+
+```js
+'use strict'
+
+const ThreadStream = require('thread-stream')
+const { join } = require('path')
+
+const stream = new ThreadStream({
+  filename: join(__dirname, 'worker.js'),
+  workerData: { dest },
+  workerOpts: {}, // Other options to be passed to Worker
+  sync: false, // default
+})
+
+stream.write('hello')
+
+// Asynchronous flushing
+stream.flush(function () {
+  stream.write(' ')
+  stream.write('world')
+
+  // Synchronous flushing
+  stream.flushSync()
+  stream.end()
+})
+```
+
+In `worker.js`:
+
+```js
+'use strict'
+
+const fs = require('fs')
+const { once } = require('events')
+
+async function run (opts) {
+  const stream = fs.createWriteStream(opts.dest)
+  await once(stream, 'open')
+  return stream
+}
+
+module.exports = run
+```
+
+Make sure that the stream emits `'close'` when the stream completes.
+This can usually be achieved by passing the [`autoDestroy: true`](https://nodejs.org/api/stream.html#stream_new_stream_writable_options)
+flag your stream classes.
+
+The underlining worker is automatically closed if the stream is garbage collected.
+
+
+### External modules
+
+You may use this module within compatible external modules, that exports the `worker.js` interface.
+
+```js
+const ThreadStream = require('thread-stream')
+
+const modulePath = require.resolve('pino-elasticsearch')
+
+const stream = new ThreadStream({
+  filename: modulePath,
+  workerData: { node: 'http://localhost:9200' }
+})
+
+stream.write('log to elasticsearch!')
+stream.flushSync()
+stream.end()
+```
+
+This module works with `yarn` in PnP (plug'n play) mode too!
+
+### Emit events
+
+You can emit events on the ThreadStream from your worker using [`worker.parentPort.postMessage()`](https://nodejs.org/api/worker_threads.html#workerparentport).
+The message (JSON object) must have the following data structure:
+
+```js
+parentPort.postMessage({
+  code: 'EVENT',
+  name: 'eventName',
+  args: ['list', 'of', 'args', 123, new Error('Boom')]
+})
+```
+
+On your ThreadStream, you can add a listener function for this event name:
+
+```js
+const stream = new ThreadStream({
+  filename: join(__dirname, 'worker.js'),
+  workerData: {},
+})
+stream.on('eventName', function (a, b, c, n, err) {
+  console.log('received:', a, b, c, n, err) // received: list of args 123 Error: Boom
+})
+```
+
+### Post Messages
+
+You can post messages to the worker by emitting a `message` event on the ThreadStream.
+
+```js
+const stream = new ThreadStream({
+  filename: join(__dirname, 'worker.js'),
+  workerData: {},
+})
+stream.emit('message', message)
+```
+
+On your worker, you can listen for this message using [`worker.parentPort.on('message', cb)`](https://nodejs.org/api/worker_threads.html#event-message).
+
+```js
+const { parentPort } = require('worker_threads')
+parentPort.on('message', function (message) {
+  console.log('received:', message)
+})
+```
+
+## License
+
+MIT

package/node_modules/thread-stream/bench.js

@@ -0,0 +1,85 @@
+'use strict'
+
+const bench = require('fastbench')
+const SonicBoom = require('sonic-boom')
+const ThreadStream = require('.')
+const Console = require('console').Console
+const fs = require('fs')
+const { join } = require('path')
+
+const core = fs.createWriteStream('/dev/null')
+const fd = fs.openSync('/dev/null', 'w')
+const sonic = new SonicBoom({ fd })
+const sonicSync = new SonicBoom({ fd, sync: true })
+const out = fs.createWriteStream('/dev/null')
+const dummyConsole = new Console(out)
+const threadStreamSync = new ThreadStream({
+  filename: join(__dirname, 'test', 'to-file.js'),
+  workerData: { dest: '/dev/null' },
+  bufferSize: 4 * 1024 * 1024,
+  sync: true
+})
+const threadStreamAsync = new ThreadStream({
+  filename: join(__dirname, 'test', 'to-file.js'),
+  workerData: { dest: '/dev/null' },
+  bufferSize: 4 * 1024 * 1024,
+  sync: false
+})
+
+const MAX = 10000
+
+let str = ''
+
+for (let i = 0; i < 100; i++) {
+  str += 'hello'
+}
+
+setTimeout(doBench, 100)
+
+const run = bench([
+  function benchThreadStreamSync (cb) {
+    for (let i = 0; i < MAX; i++) {
+      threadStreamSync.write(str)
+    }
+    setImmediate(cb)
+  },
+  function benchThreadStreamAsync (cb) {
+    threadStreamAsync.once('drain', cb)
+    for (let i = 0; i < MAX; i++) {
+      threadStreamAsync.write(str)
+    }
+  },
+  function benchSonic (cb) {
+    sonic.once('drain', cb)
+    for (let i = 0; i < MAX; i++) {
+      sonic.write(str)
+    }
+  },
+  function benchSonicSync (cb) {
+    sonicSync.once('drain', cb)
+    for (let i = 0; i < MAX; i++) {
+      sonicSync.write(str)
+    }
+  },
+  function benchCore (cb) {
+    core.once('drain', cb)
+    for (let i = 0; i < MAX; i++) {
+      core.write(str)
+    }
+  },
+  function benchConsole (cb) {
+    for (let i = 0; i < MAX; i++) {
+      dummyConsole.log(str)
+    }
+    setImmediate(cb)
+  }
+], 1000)
+
+function doBench () {
+  run(function () {
+    run(function () {
+      // TODO figure out why it does not shut down
+      process.exit(0)
+    })
+  })
+}

package/node_modules/thread-stream/eslint.config.js

@@ -0,0 +1,10 @@
+'use strict'
+
+const neostandard = require('neostandard')
+
+module.exports = neostandard({
+  ignores: [
+    'test/ts/**/*',
+    'test/syntax-error.mjs'
+  ]
+})

package/node_modules/thread-stream/index.d.ts

@@ -0,0 +1,92 @@
+import { EventEmitter } from 'events'
+import * as workerThreads from 'worker_threads'
+
+interface ThreadStreamOptions {
+  /**
+   * The size (in bytes) of the buffer.
+   * Must be greater than 4 (i.e. it must at least fit a 4-byte utf-8 char).
+   * 
+   * Default: `4 * 1024 * 1024` = `4194304`
+   */
+  bufferSize?: number,
+  /**
+   * The path to the Worker's main script or module.
+   * Must be either an absolute path or a relative path (i.e. relative to the current working directory) starting with ./ or ../, or a WHATWG URL object using file: or data: protocol.
+   * When using a data: URL, the data is interpreted based on MIME type using the ECMAScript module loader.
+   * 
+   * {@link workerThreads.Worker()}
+   */
+  filename: string | URL,
+  /**
+   * If `true`, write data synchronously; otherwise write data asynchronously.
+   * 
+   * Default: `false`.
+   */
+  sync?: boolean,
+  /**
+   * {@link workerThreads.WorkerOptions.workerData}
+   * 
+   * Default: `{}`
+   */
+  workerData?: any,
+  /**
+   * {@link workerThreads.WorkerOptions}
+   * 
+   * Default: `{}`
+   */
+  workerOpts?: workerThreads.WorkerOptions
+}
+
+
+declare class ThreadStream extends EventEmitter {
+  /**
+   * @param {ThreadStreamOptions} opts 
+   */
+  constructor(opts: ThreadStreamOptions)
+  /**
+   * Write some data to the stream.
+   * 
+   * **Please note that this method should not throw an {Error} if something goes wrong but emit an error event.**
+   * @param {string} data data to write.
+   * @returns {boolean} false if the stream wishes for the calling code to wait for the 'drain' event to be emitted before continuing to write additional data or if it fails to write; otherwise true.
+   */
+  write(data: string): boolean
+  /**
+   * Signal that no more data will be written.
+   * 
+   * **Please note that this method should not throw an {Error} if something goes wrong but emit an error event.**
+   * 
+   * Calling the {@link write()} method after calling {@link end()} will emit an error.
+   */
+  end(): void
+  /**
+   * Flush the stream synchronously.
+   * This method should be called in the shutdown phase to make sure that all data has been flushed.
+   * 
+   * **Please note that this method will throw an {Error} if something goes wrong.**
+   * 
+   * @throws {Error} if the stream is already flushing, if it fails to flush or if it takes more than 10 seconds to flush.
+   */
+  flushSync(): void
+  /**
+   * Synchronously calls each of the listeners registered for the event named`eventName`, in the order they were registered, passing the supplied arguments
+   * to each.
+   *
+   * @param eventName the name of the event.
+   * @param args the arguments to be passed to the event handlers.
+   * @returns {boolean} `true` if the event had listeners, `false` otherwise.
+   */
+  emit(eventName: string | symbol, ...args: any[]): boolean;
+
+  /**
+   * Post a message to the Worker with specified data and an optional list of transferable objects.
+   *
+   * @param eventName the name of the event, specifically 'message'.
+   * @param message message data to be sent to the Worker.
+   * @param transferList an optional list of transferable objects to be transferred to the Worker context.
+   * @returns {boolean} true if the event had listeners, false otherwise.
+   */
+  emit(eventName: 'message', message: any, transferList?: workerThreads.TransferListItem[]): boolean
+}
+
+export = ThreadStream;