@valkey/valkey-glide-darwin-arm64 1.2.0 → 1.2.1-rc0

package/node_modules/glide-rs/index.d.ts

@@ -12,7 +12,8 @@ export const enum Level {
     Off = 5,
 }
 export const MAX_REQUEST_ARGS_LEN: number
-export const DEFAULT_TIMEOUT_IN_MILLISECONDS: number
+export const DEFAULT_REQUEST_TIMEOUT_IN_MILLISECONDS: number
+export const DEFAULT_CONNECTION_TIMEOUT_IN_MILLISECONDS: number
 export const DEFAULT_INFLIGHT_REQUESTS_LIMIT: number
 export declare function StartSocketConnection(): Promise<string>
 export declare function log(logLevel: Level, logIdentifier: string, message: string): void

package/node_modules/glide-rs/index.js

@@ -287,7 +287,8 @@ if (!nativeBinding) {
 const {
     Level,
     MAX_REQUEST_ARGS_LEN,
-    DEFAULT_TIMEOUT_IN_MILLISECONDS,
+    DEFAULT_REQUEST_TIMEOUT_IN_MILLISECONDS,
+    DEFAULT_CONNECTION_TIMEOUT_IN_MILLISECONDS,
     DEFAULT_INFLIGHT_REQUESTS_LIMIT,
     AsyncClient,
     StartSocketConnection,
@@ -302,7 +303,8 @@ const {
 
 module.exports.Level = Level
 module.exports.MAX_REQUEST_ARGS_LEN = MAX_REQUEST_ARGS_LEN
-module.exports.DEFAULT_TIMEOUT_IN_MILLISECONDS = DEFAULT_TIMEOUT_IN_MILLISECONDS
+module.exports.DEFAULT_REQUEST_TIMEOUT_IN_MILLISECONDS = DEFAULT_REQUEST_TIMEOUT_IN_MILLISECONDS
+module.exports.DEFAULT_CONNECTION_TIMEOUT_IN_MILLISECONDS = DEFAULT_CONNECTION_TIMEOUT_IN_MILLISECONDS
 module.exports.DEFAULT_INFLIGHT_REQUESTS_LIMIT = DEFAULT_INFLIGHT_REQUESTS_LIMIT
 module.exports.AsyncClient = AsyncClient
 module.exports.StartSocketConnection = StartSocketConnection

package/npm/glide/index.ts

@@ -53,9 +53,6 @@ function loadNativeBinding() {
             break;
         case "darwin":
             switch (arch) {
-                case "x64":
-                    nativeBinding = require("@scope/valkey-glide-darwin-x64");
-                    break;
                 case "arm64":
                     nativeBinding = require("@scope/valkey-glide-darwin-arm64");
                     break;
@@ -216,6 +213,8 @@ function initialize() {
         Script,
         ObjectType,
         ClusterScanCursor,
+        AdvancedGlideClientConfiguration,
+        AdvancedGlideClusterClientConfiguration,
         BaseClientConfiguration,
         GlideClusterClientConfiguration,
         LevelOptions,
@@ -293,6 +292,8 @@ function initialize() {
         GlideClient,
         GlideClusterClient,
         GlideClientConfiguration,
+        AdvancedGlideClientConfiguration,
+        AdvancedGlideClusterClientConfiguration,
         FunctionListOptions,
         FunctionListResponse,
         FunctionStatsSingleResponse,

package/npm/glide/package.json

@@ -41,7 +41,6 @@
     },
     "optionalDependencies": {
         "${scope}valkey-glide-darwin-arm64": "${package_version}",
-        "${scope}valkey-glide-darwin-x64": "${package_version}",
         "${scope}valkey-glide-linux-arm64": "${package_version}",
         "${scope}valkey-glide-linux-x64": "${package_version}",
         "${scope}valkey-glide-linux-musl-arm64": "${package_version}",

package/package.json

@@ -34,7 +34,7 @@
         "test": "npm run build-test-utils && jest --verbose --testPathIgnorePatterns='ServerModules'",
         "test-dbg": "npm run build-test-utils && jest --runInBand",
         "test-minimum": "npm run build-test-utils && jest --verbose --testNamePattern='^(.(?!(GlideJson|GlideFt|pubsub|kill)))*$'",
-        "test-modules": "npm run build-test-utils && jest --verbose --testNamePattern='(GlideJson|GlideFt)'",
+        "test-modules": "npm run build-test-utils && jest --runInBand --verbose --testNamePattern='(GlideJson|GlideFt)'",
         "build-test-utils": "cd ../utils && npm i && npm run build",
         "lint:fix": "npm run install-linting && npx eslint -c ../eslint.config.mjs --fix && npm run prettier:format",
         "lint": "npm run install-linting && npx eslint -c ../eslint.config.mjs && npm run prettier:check:ci",
@@ -92,5 +92,5 @@
         "darwin"
     ],
     "name": "@valkey/valkey-glide-darwin-arm64",
-    "version": "1.2.0"
+    "version": "1.2.1-rc0"
 }

package/rust-client/node_modules/mingo/README.md

@@ -29,7 +29,7 @@ MongoDB query language for in-memory objects
 
 For more documentation on how to use operators see [mongodb](http://docs.mongodb.org/manual/reference/operator/).
 
-Browse [package docs](http://kofrasa.net/mingo/) for modules.
+Browse [package docs](http://kofrasa.github.io/mingo/) for modules.
 
 ## Usage
 
@@ -63,12 +63,12 @@ To support tree-shaking for client side bundles, you can import and register spe
 ### ES6
 
 ```js
-import { useOperators, OperatorType } from "mingo/core";
+import { useOperators } from "mingo/core";
 import { $trunc } from "mingo/operators/expression";
 import { $bucket } from "mingo/operators/pipeline";
 
-useOperators(OperatorType.EXPRESSION, { $trunc });
-useOperators(OperatorType.PIPELINE, { $bucket });
+useOperators("expression", { $trunc });
+useOperators("pipeline", { $bucket });
 ```
 
 ### CommonJS
@@ -78,10 +78,9 @@ const core = require("mingo/core");
 const $trunc = require("mingo/operators/expression").$trunc;
 const $bucket = require("mingo/operators/pipeline").$bucket;
 const useOperators = core.useOperators;
-const OperatorType = core.OperatorType;
 
-useOperators(OperatorType.EXPRESSION, { $trunc: $trunc });
-useOperators(OperatorType.PIPELINE, { $bucket: $bucket });
+useOperators("expression", { $trunc: $trunc });
+useOperators("pipeline", { $bucket: $bucket });
 ```
 
 ## Using query to test objects
@@ -144,14 +143,14 @@ No default implementation is provided out of the box so users can use a library
 The example below uses [Ajv](https://www.npmjs.com/package/ajv) to implement schema validation.
 
 ```js
-import { RawObject } from "mingo/types"
+import { AnyObject } from "mingo/types"
 import { JsonSchemaValidator } from "mingo/core"
 import Ajv, { Schema } from "ajv"
 
-const jsonSchemaValidator: JsonSchemaValidator = (s: RawObject) => {
+const jsonSchemaValidator: JsonSchemaValidator = (s: AnyObject) => {
   const ajv = new Ajv();
   const v = ajv.compile(s as Schema);
-  return (o: RawObject) => (v(o) ? true : false);
+  return (o: AnyObject) => (v(o) ? true : false);
 };
 
 const schema = {
@@ -183,13 +182,13 @@ find(docs, { $jsonSchema: schema }, {}, { jsonSchemaValidator }).all();
 
 ```js
 import { Aggregator } from "mingo/aggregator";
-import { useOperators, OperatorType } from "mingo/core";
+import { useOperators } from "mingo/core";
 import { $match, $group } from "mingo/operators/pipeline";
 import { $min } from "mingo/operators/accumulator";
 
 // ensure the required operators are preloaded prior to using them.
-useOperators(OperatorType.PIPELINE, { $match, $group });
-useOperators(OperatorType.ACCUMULATOR, { $min });
+useOperators("pipeline", { $match, $group });
+useOperators("accumulator", { $min });
 
 let agg = new Aggregator([
   { $match: { type: "homework" } },
@@ -208,56 +207,56 @@ let result = agg.run(collection);
 
 Query and aggregation operations can be configured with options to enabled different features or customize how documents are processed. Some options are only relevant to specific operators and need not be specified if not required.
 
-| Name                | Description                                                                                                                            | Default                                                              | Behaviour                                                                                                                                                                                                                                                                                                                                           |
-| ------------------- | -------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| idKey               | The key that is used to lookup the ID value of a document.                                                                             | "\_id"                                                               |                                                                                                                                                                                                                                                                                                                                                     |
-| collation           | [Collation](http://kofrasa.net/mingo/interfaces/core.CollationSpec.html) specification for string sorting operations.                  | _none_                                                               | See [Intl.Collator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Collator)                                                                                                                                                                                                                                 |
-| processingMode      | Determines copy rules for inputs and outputs.                                                                                          | [CLONE_OFF](http://kofrasa.net/mingo/enums/core.ProcessingMode.html) | Turn off cloning and modifies the input collection as needed. <br>This option will also return output objects with shared paths in their graph when specific operators are used. Provides the greatest speedup by minizing cloning. When using the aggregation pipeline, you can use the `$out` operator to collect immutable intermediate results. |
-| useStrictMode       | Enforces strict MongoDB compatibilty.                                                                                                  | true                                                                 | When disabled, behaviour changes as follows. <ul><li>`$elemMatch` returns all matching nested documents instead of only the first.</li><li>Empty string `""` is coerced to false during boolean checking in supported operators which is consistent with Javascript semantics.</li><ul>                                                             |
-| scriptEnabled       | Enable or disable using custom script execution.                                                                                       | true                                                                 | When disabled, operators that execute custom code are disallowed such as; `$where`, `$accumulator`, and `$function`.                                                                                                                                                                                                                                |
-| hashFunction        | Custom hash function to replace the default based on "Effective Java" hashCode.                                                        | _default_                                                            | Expects function `(value: unknown) => number`.                                                                                                                                                                                                                                                                                                      |
-| collectionResolver  | Function to resolve strings to arrays for use with operators that reference other collections such as; `$lookup`, `$out` and `$merge`. | _none_                                                               | Expects function `(name: string) => RawObject[]`                                                                                                                                                                                                                                                                                                    |
-| jsonSchemaValidator | JSON schema validator to use for the `$jsonSchema` operator.                                                                           | _none_                                                               | Expects function `(schema: RawObject) => (document: RawObject) => boolean`.<br> The `$jsonSchema` operation would fail if a validator is not provided.                                                                                                                                                                                              |
-| variables           | Global variables to pass to all operators                                                                                              | _none_                                                               |                                                                                                                                                                                                                                                                                                                                                     |
-| context             | Container to use for loading operators.                                                                                                | _none_                                                               | This option allow users to load only desired operators or register custom operators which need not be available globally.                                                                                                                                                                                                                           |
-| useGlobalContext    | Allow falling back to the global context when operator is not found in the provided context.                                           | true                                                                 | This is provided to allow users to strictly enforce which operators may be usable.                                                                                                                                                                                                                                                                  |
+| Name                | Description                                                                                                                            | Default                                                                    | Behaviour                                                                                                                                                                                                                                                                                                                                           |
+| ------------------- | -------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| idKey               | The key that is used to lookup the ID value of a document.                                                                             | "\_id"                                                                     |                                                                                                                                                                                                                                                                                                                                                     |
+| collation           | [Collation](http://kofrasa.github.io/mingo/interfaces/core.CollationSpec.html) specification for string sorting operations.            | _none_                                                                     | See [Intl.Collator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Collator)                                                                                                                                                                                                                                 |
+| processingMode      | Determines copy rules for inputs and outputs.                                                                                          | [CLONE_OFF](http://kofrasa.github.io/mingo/enums/core.ProcessingMode.html) | Turn off cloning and modifies the input collection as needed. <br>This option will also return output objects with shared paths in their graph when specific operators are used. Provides the greatest speedup by minizing cloning. When using the aggregation pipeline, you can use the `$out` operator to collect immutable intermediate results. |
+| useStrictMode       | Enforces strict MongoDB compatibilty.                                                                                                  | true                                                                       | When disabled, behaviour changes as follows. <ul><li>`$elemMatch` returns all matching nested documents instead of only the first.</li><li>Empty string `""` is coerced to false during boolean checking in supported operators which is consistent with Javascript semantics.</li><li>`$type` returns JS native type names as follows. <ul><li>`"missing"` -> `"undefined"`</li><li>`"bool"` -> `"boolean"`</li><li> `"int"\|"long"\|"double"` -> `"number"`</li><li>`"regex"` -> `"regexp"`</li></ul><ul>                                                             |
+| scriptEnabled       | Enable or disable using custom script execution.                                                                                       | true                                                                       | When disabled, operators that execute custom code are disallowed such as; `$where`, `$accumulator`, and `$function`.                                                                                                                                                                                                                                |
+| hashFunction        | Custom hash function to replace the default based on "Effective Java" hashCode.                                                        | _default_                                                                  | Expects function `(value: unknown) => number`.                                                                                                                                                                                                                                                                                                      |
+| collectionResolver  | Function to resolve strings to arrays for use with operators that reference other collections such as; `$lookup`, `$out` and `$merge`. | _none_                                                                     | Expects function `(name: string) => AnyObject[]`                                                                                                                                                                                                                                                                                                    |
+| jsonSchemaValidator | JSON schema validator to use for the `$jsonSchema` operator.                                                                           | _none_                                                                     | Expects function `(schema: AnyObject) => (document: AnyObject) => boolean`.<br> The `$jsonSchema` operation would fail if a validator is not provided.                                                                                                                                                                                              |
+| variables           | Global variables to pass to all operators                                                                                              | _none_                                                                     |                                                                                                                                                                                                                                                                                                                                                     |
+| context             | Container to use for loading operators.                                                                                                | _none_                                                                     | This option allow users to load only desired operators or register custom operators which need not be available globally.                                                                                                                                                                                                                           |
+| useGlobalContext    | Allow falling back to the global context when operator is not found in the provided context.                                           | true                                                                       | This is provided to allow users to strictly enforce which operators may be usable.                                                                                                                                                                                                                                                                  |
 
 ## Adding Custom Operators
 
-Custom operators can be registered using `Context` via the `context` option which is the recommended way from `6.4.2`. The `Context` is a container for operators, that the execution engine will use to process queries. Previously, the [useOperators(...)](http://kofrasa.net/mingo/modules/core.html#useOperators) function was used to register operators globally but that is no longer preferred. The difference between the two is that a globally registered operator cannot be overwritten whereas a new context may be created and used at anytime.
+Custom operators can be registered using `Context` via the `context` option which is the recommended way from `6.4.2`. The `Context` is a container for operators, that the execution engine will use to process queries. Previously, the [useOperators(...)](https://kofrasa.github.io/mingo/functions/core.useOperators.html) function was used to register operators globally but that is no longer preferred. The difference between the two is that a globally registered operator cannot be overwritten whereas a new context may be created and used at anytime.
 
 **NB: Note that the execution engine will first try to find the operator in the context and fallback to the global context when not found.**
 
 Each operator type has a specific interface to which an implementation must conform to be valid.
 
-- [AccumulatorOperator](http://kofrasa.net/mingo/types/core.AccumulatorOperator.html)
-- [ExpressionOperator](http://kofrasa.net/mingo/types/core.ExpressionOperator.html)
-- [ProjectionOperator](http://kofrasa.net/mingo/types/core.ProjectionOperator.html)
-- [PipelineOperator](http://kofrasa.net/mingo/types/core.PipelineOperator.html)
-- [WindowOperator](http://kofrasa.net/mingo/types/core.WindowOperator.html)
-- [QueryOperator](http://kofrasa.net/mingo/types/core.QueryOperator.html)
+- [AccumulatorOperator](http://kofrasa.github.io/mingo/types/core.AccumulatorOperator.html)
+- [ExpressionOperator](http://kofrasa.github.io/mingo/types/core.ExpressionOperator.html)
+- [ProjectionOperator](http://kofrasa.github.io/mingo/types/core.ProjectionOperator.html)
+- [PipelineOperator](http://kofrasa.github.io/mingo/types/core.PipelineOperator.html)
+- [WindowOperator](http://kofrasa.github.io/mingo/types/core.WindowOperator.html)
+- [QueryOperator](http://kofrasa.github.io/mingo/types/core.QueryOperator.html)
 
 Pre-loaded operators defined [here](https://github.com/kofrasa/mingo/blob/master/src/init/basic.ts) cannot be overridden. These include;
 
-- All [query](http://kofrasa.net/mingo/modules/operators_query.html) operators.
-- All [projection](http://kofrasa.net/mingo/modules/operators_projection.html) operators.
-- Expression operators for [boolean](http://kofrasa.net/mingo/modules/operators_expression_boolean.html) and [comparison](http://kofrasa.net/mingo/modules/operators_expression_comparison.html).
-- Pipeline [operators](http://kofrasa.net/mingo/modules/operators_pipeline.html); `$project`, `$skip`, `$limit`, and `$sort`.
+- All [query](http://kofrasa.github.io/mingo/modules/operators_query.html) operators.
+- All [projection](http://kofrasa.github.io/mingo/modules/operators_projection.html) operators.
+- Expression operators for [boolean](http://kofrasa.github.io/mingo/modules/operators_expression_boolean.html) and [comparison](http://kofrasa.github.io/mingo/modules/operators_expression_comparison.html).
+- Pipeline [operators](http://kofrasa.github.io/mingo/modules/operators_pipeline.html); `$project`, `$skip`, `$limit`, and `$sort`.
 
 > NB: _Update operators is not supported in `Context`._
 
 ## Updating Documents
 
-An update operation can be performed using the `updateObject` function from the `mingo/updater` module. Unlike other operations in the library, this only works on a single object.
+An update operation can be performed using the `update` function from the `mingo/updater` module. Unlike other operations in the library, this only works on a single object.
 The query and aggregation operators are powerful enough to use for transforming arrays of documents and should be preferred when dealing with multiple objects.
-`updateObject` returns an array of all paths that were updated. It also supports [arrayFilters](https://www.mongodb.com/docs/manual/release-notes/3.6/#std-label-3.6-arrayFilters) for applicable operators. To detect whether a change occured you can check the length of the returned array.
+`update` returns an array of all paths that were updated. It also supports [arrayFilters](https://www.mongodb.com/docs/manual/release-notes/3.6/#std-label-3.6-arrayFilters) for applicable operators. To detect whether a change occured you can check the length of the returned array.
 
 All operators as of MongoDB 5.0 are supported except the positional array operator `$`.
 
 ### Examples
 
 ```ts
-import { updateObject } from "mingo/updater";
+import { update } from "mingo";
 // all update operators are automatically loaded.
 
 const obj = {
@@ -268,16 +267,16 @@ const obj = {
 };
 
 // returns array of modified paths if value changed.
-updateObject(obj, { $set: { firstName: "Bob", lastName: "Doe" } }); // ["firstName", "lastName"]
+update(obj, { $set: { firstName: "Bob", lastName: "Doe" } }); // ["firstName", "lastName"]
 
 // update nested values.
-updateObject(obj, { $pop: { friends: 1 } }); // ["friends"] => friends: ["Scooby", "Shagy"]
+update(obj, { $pop: { friends: 1 } }); // ["friends"] => friends: ["Scooby", "Shagy"]
 // update nested value path
-updateObject(obj, { $unset: { "friends.1": "" } }); // ["friends.1"] => friends: ["Scooby", null]
+update(obj, { $unset: { "friends.1": "" } }); // ["friends.1"] => friends: ["Scooby", null]
 // update with condition
-updateObject(obj, { $set: { "friends.$[e]": "Velma" } }, [{ e: null }]); // ["friends"] => friends: ["Scooby", "Velma"]
+update(obj, { $set: { "friends.$[e]": "Velma" } }, [{ e: null }]); // ["friends"] => friends: ["Scooby", "Velma"]
 // empty array returned if value has not changed.
-updateObject(obj, { $set: { fristName: "Bob" } }); // [] => no change to object.
+update(obj, { $set: { fristName: "Bob" } }); // [] => no change to object.
 ```
 
 You can also create a preconfigured updater function.
@@ -286,14 +285,14 @@ You can also create a preconfigured updater function.
 import { createUpdater } from "mingo/updater";
 
 // configure updater to deep clone passed values. clone mode defaults to "copy".
-const updateObject = createUpdater({ cloneMode: "deep" });
+const updateState = createUpdater({ cloneMode: "deep" });
 
 const state = { people: ["Fred", "John"] };
 const newPeople = ["Amy", "Mark"];
 
 console.log(state.people); // ["Fred", "John"]
 
-updateObject(state, { $set: { people: newPeople } });
+updateState(state, { $set: { people: newPeople } });
 
 newPeople.push("Jason");
 
@@ -303,15 +302,21 @@ console.log(newPeople); // ["Amy", "Mark", "Jason"]
 
 ## Differences from MongoDB
 
-This list describes how this library differs from the full MongoDB query engine.
+Below is a description of how this library differs from the full MongoDB query engine.
 
-1. There is no concept of a collection. Input data is either an array of objects or a generator function to support streaming.
+1. There is no concept of a collection. Input is an array, generator or iterable of objects.
+1. Support a single numeric type `number`.
+1. When `useStrictMode` is `false`, replace MongoDB [types](https://www.mongodb.com/docs/manual/reference/operator/aggregation/type/#available-types) with JS native types as follows;
+   - `"bool"` -> `"boolean"`.
+   - `"int"|"long"|"double"|"decimal"` -> `"number"`.
+   - `"missing"` -> `"undefined"`.
+1. Does not support [types](https://www.mongodb.com/docs/manual/reference/operator/aggregation/type/#available-types) `"minKey"`, `"maxKey"`, `"timestamp"`, or `"binData"`.
 1. Does not support server specific operators. E.g. `$collStat`, `$planCacheStats`, `$listSessions`.
-1. Does not support geometry query operators. **no support planned**.
+1. Does not support geometry query operators.
 1. Does not support query operators dependent on persistent storage; `$comment`, `$meta`, `$text`.
 1. Does not support positional query or update operator `$`.
 1. Does not support server specific expression operators; `$toObjectId`, `$binarySize`, `bsonSize`.
-1. Agregation pipeline operator `$merge` enforces unique constraint on the lookup field at runtime.
+1. Agregation pipeline operator `$merge` enforces unique constraint on the lookup field during input processing.
 1. Custom function evaluation operators; `$where`, `$function`, and `$accumulator`, do not accept strings as the function body.
 1. Custom function evaluation operators are enabled by default. They can be disabled with the `scriptEnabled` option.
 1. Custom function evaluation operator [$accumulator](https://docs.mongodb.com/manual/reference/operator/aggregation/accumulator/) does not support the `merge` option.
@@ -331,9 +336,9 @@ This list describes how this library differs from the full MongoDB query engine.
 - Run `npm test` to build and run unit tests.
 - Submit pull request.
 
-To validate correct behaviour and semantics of operators, you may also test against [mongoplayground.net](https://mongoplayground.net/). _Credit to the [author](https://github.com/feliixx)_.
+To validate correct behaviour and semantics of operators, you may also test against [mongoplayground.net](https://mongoplayground.net/). Credit to the author _[@feliix](https://github.com/feliixx)_.
 
-_A big thank you to all users and [CONTRIBUTORS](https://github.com/kofrasa/mingo/graphs/contributors) of this library._
+A big thank you to all users and [CONTRIBUTORS](https://github.com/kofrasa/mingo/graphs/contributors) of this library.
 
 ## License
 

package/rust-client/node_modules/mingo/dist/cjs/aggregator.js

@@ -24,41 +24,40 @@ var import_core = require("./core");
 var import_lazy = require("./lazy");
 var import_util = require("./util");
 class Aggregator {
+  #pipeline;
+  #options;
   constructor(pipeline, options) {
-    this.pipeline = pipeline;
-    this.options = (0, import_core.initOptions)(options);
+    this.#pipeline = pipeline;
+    this.#options = (0, import_core.initOptions)(options);
   }
   /**
-   * Returns an `Lazy` iterator for processing results of pipeline
+   * Returns an {@link Iterator} for lazy evaluation of the pipeline.
    *
    * @param {*} collection An array or iterator object
    * @returns {Iterator} an iterator object
    */
-  stream(collection) {
+  stream(collection, options) {
     let iterator = (0, import_lazy.Lazy)(collection);
-    const mode = this.options.processingMode;
+    const opts = options ?? this.#options;
+    const mode = opts.processingMode;
     if (mode == import_core.ProcessingMode.CLONE_ALL || mode == import_core.ProcessingMode.CLONE_INPUT) {
       iterator.map(import_util.cloneDeep);
     }
-    const pipelineOperators = new Array();
-    if (!(0, import_util.isEmpty)(this.pipeline)) {
-      for (const operator of this.pipeline) {
+    const stages = new Array();
+    if (!(0, import_util.isEmpty)(this.#pipeline)) {
+      for (const operator of this.#pipeline) {
         const operatorKeys = Object.keys(operator);
         const opName = operatorKeys[0];
-        const call = (0, import_core.getOperator)(
-          import_core.OperatorType.PIPELINE,
-          opName,
-          this.options
-        );
+        const call = (0, import_core.getOperator)("pipeline", opName, opts);
         (0, import_util.assert)(
           operatorKeys.length === 1 && !!call,
           `invalid pipeline operator ${opName}`
         );
-        pipelineOperators.push(opName);
-        iterator = call(iterator, operator[opName], this.options);
+        stages.push(opName);
+        iterator = call(iterator, operator[opName], opts);
       }
     }
-    if (mode == import_core.ProcessingMode.CLONE_OUTPUT || mode == import_core.ProcessingMode.CLONE_ALL && !!(0, import_util.intersection)([["$group", "$unwind"], pipelineOperators]).length) {
+    if (mode == import_core.ProcessingMode.CLONE_OUTPUT || mode == import_core.ProcessingMode.CLONE_ALL && !!(0, import_util.intersection)([["$group", "$unwind"], stages]).length) {
       iterator.map(import_util.cloneDeep);
     }
     return iterator;
@@ -66,11 +65,10 @@ class Aggregator {
   /**
    * Return the results of the aggregation as an array.
    *
-   * @param {*} collection
-   * @param {*} query
+   * @param collection
    */
-  run(collection) {
-    return this.stream(collection).value();
+  run(collection, options) {
+    return this.stream(collection, options).value();
   }
 }
 // Annotate the CommonJS export names for ESM import in node: