@psnext/slingcli 2.5.20260710-1 → 2.5.20260718-2

package/node_modules/@smithy/types/dist-types/ts3.4/transfer.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @public
+ */
+export type RequestHandlerOutput<ResponseType> = {
+    response: ResponseType;
+};
+/**
+ * @public
+ */
+export interface RequestHandler<RequestType, ResponseType, HandlerOptions = {}> {
+    /**
+     * metadata contains information of a handler. For example
+     * 'h2' refers this handler is for handling HTTP/2 requests,
+     * whereas 'h1' refers handling HTTP1 requests
+     */
+    metadata?: RequestHandlerMetadata;
+    destroy?: () => void;
+    handle: (request: RequestType, handlerOptions?: HandlerOptions) => Promise<RequestHandlerOutput<ResponseType>>;
+}
+/**
+ * @public
+ */
+export interface RequestHandlerMetadata {
+    handlerProtocol: RequestHandlerProtocol | string;
+}
+/**
+ * Values from ALPN Protocol IDs.
+ *
+ * @public
+ * @see https://www.iana.org/assignments/tls-extensiontype-values/tls-extensiontype-values.xhtml#alpn-protocol-ids
+ */
+export declare enum RequestHandlerProtocol {
+    HTTP_0_9 = "http/0.9",
+    HTTP_1_0 = "http/1.0",
+    TDS_8_0 = "tds/8.0"
+}
+/**
+ * @public
+ */
+export interface RequestContext {
+    destination: URL;
+}

package/node_modules/@smithy/types/dist-types/ts3.4/transform/client-method-transforms.d.ts

@@ -0,0 +1,26 @@
+import { CommandIO } from "../command";
+import { MetadataBearer } from "../response";
+import { StreamingBlobPayloadOutputTypes } from "../streaming-payload/streaming-blob-payload-output-types";
+import { Transform } from "./type-transform";
+/**
+ * Narrowed version of InvokeFunction used in Client::send.
+ *
+ * @internal
+ */
+export interface NarrowedInvokeFunction<NarrowType, HttpHandlerOptions, InputTypes extends object, OutputTypes extends MetadataBearer> {
+    <InputType extends InputTypes, OutputType extends OutputTypes>(command: CommandIO<InputType, OutputType>, options?: HttpHandlerOptions): Promise<Transform<OutputType, StreamingBlobPayloadOutputTypes | undefined, NarrowType>>;
+    <InputType extends InputTypes, OutputType extends OutputTypes>(command: CommandIO<InputType, OutputType>, cb: (err: unknown, data?: Transform<OutputType, StreamingBlobPayloadOutputTypes | undefined, NarrowType>) => void): void;
+    <InputType extends InputTypes, OutputType extends OutputTypes>(command: CommandIO<InputType, OutputType>, options: HttpHandlerOptions, cb: (err: unknown, data?: Transform<OutputType, StreamingBlobPayloadOutputTypes | undefined, NarrowType>) => void): void;
+    <InputType extends InputTypes, OutputType extends OutputTypes>(command: CommandIO<InputType, OutputType>, options?: HttpHandlerOptions, cb?: (err: unknown, data?: Transform<OutputType, StreamingBlobPayloadOutputTypes | undefined, NarrowType>) => void): Promise<Transform<OutputType, StreamingBlobPayloadOutputTypes | undefined, NarrowType>> | void;
+}
+/**
+ * Narrowed version of InvokeMethod used in aggregated Client methods.
+ *
+ * @internal
+ */
+export interface NarrowedInvokeMethod<NarrowType, HttpHandlerOptions, InputType extends object, OutputType extends MetadataBearer> {
+    (input: InputType, options?: HttpHandlerOptions): Promise<Transform<OutputType, StreamingBlobPayloadOutputTypes | undefined, NarrowType>>;
+    (input: InputType, cb: (err: unknown, data?: Transform<OutputType, StreamingBlobPayloadOutputTypes | undefined, NarrowType>) => void): void;
+    (input: InputType, options: HttpHandlerOptions, cb: (err: unknown, data?: Transform<OutputType, StreamingBlobPayloadOutputTypes | undefined, NarrowType>) => void): void;
+    (input: InputType, options?: HttpHandlerOptions, cb?: (err: unknown, data?: OutputType) => void): Promise<Transform<OutputType, StreamingBlobPayloadOutputTypes | undefined, NarrowType>> | void;
+}

package/node_modules/@smithy/types/dist-types/ts3.4/transform/client-payload-blob-type-narrow.d.ts

@@ -0,0 +1,77 @@
+import { ClientHttp2Stream } from "node:http2";
+import { IncomingMessage } from "node:http";
+import { InvokeMethod } from "../client";
+import { GetOutputType } from "../command";
+import { HttpHandlerOptions } from "../http";
+import { SdkStream } from "../serde";
+import { BrowserRuntimeStreamingBlobPayloadInputTypes, NodeJsRuntimeStreamingBlobPayloadInputTypes, StreamingBlobPayloadInputTypes } from "../streaming-payload/streaming-blob-payload-input-types";
+import { StreamingBlobPayloadOutputTypes } from "../streaming-payload/streaming-blob-payload-output-types";
+import { NarrowedInvokeMethod } from "./client-method-transforms";
+import { Transform } from "./type-transform";
+/**
+ * Creates a type with a given client type that narrows payload blob output
+ * types to SdkStream<IncomingMessage>.
+ * This can be used for clients with the NodeHttpHandler requestHandler,
+ * the default in Node.js when not using HTTP2.
+ * Usage example:
+ * ```typescript
+ * const client = new YourClient({}) as NodeJsClient<YourClient>;
+ * ```
+ *
+ * @public
+ */
+export type NodeJsClient<ClientType extends object> = NarrowPayloadBlobTypes<NodeJsRuntimeStreamingBlobPayloadInputTypes, SdkStream<IncomingMessage>, ClientType>;
+/**
+ * Variant of NodeJsClient for node:http2.
+ *
+ * @public
+ */
+export type NodeJsHttp2Client<ClientType extends object> = NarrowPayloadBlobTypes<NodeJsRuntimeStreamingBlobPayloadInputTypes, SdkStream<ClientHttp2Stream>, ClientType>;
+/**
+ * Creates a type with a given client type that narrows payload blob output
+ * types to SdkStream<ReadableStream>.
+ * This can be used for clients with the FetchHttpHandler requestHandler,
+ * which is the default in browser environments.
+ * Usage example:
+ * ```typescript
+ * const client = new YourClient({}) as BrowserClient<YourClient>;
+ * ```
+ *
+ * @public
+ */
+export type BrowserClient<ClientType extends object> = NarrowPayloadBlobTypes<BrowserRuntimeStreamingBlobPayloadInputTypes, SdkStream<ReadableStream>, ClientType>;
+/**
+ * Variant of BrowserClient for XMLHttpRequest.
+ *
+ * @public
+ */
+export type BrowserXhrClient<ClientType extends object> = NarrowPayloadBlobTypes<BrowserRuntimeStreamingBlobPayloadInputTypes, SdkStream<ReadableStream | Blob>, ClientType>;
+/**
+ * Narrow a given Client's blob payload outputs to the given type T.
+ *
+ * @public
+ * @deprecated use NarrowPayloadBlobTypes<I, O, ClientType>.
+ */
+export type NarrowPayloadBlobOutputType<T, ClientType extends object> = {
+    [key in keyof ClientType]: [
+        ClientType[key]
+    ] extends [
+        InvokeMethod<infer FunctionInputTypes, infer FunctionOutputTypes>
+    ] ? NarrowedInvokeMethod<T, HttpHandlerOptions, FunctionInputTypes, FunctionOutputTypes> : ClientType[key];
+} & {
+    send<Command>(command: Command, options?: any): Promise<Transform<GetOutputType<Command>, StreamingBlobPayloadOutputTypes | undefined, T>>;
+};
+/**
+ * Narrow a Client's blob payload input and output types to I and O.
+ *
+ * @public
+ */
+export type NarrowPayloadBlobTypes<I, O, ClientType extends object> = {
+    [key in keyof ClientType]: [
+        ClientType[key]
+    ] extends [
+        InvokeMethod<infer FunctionInputTypes, infer FunctionOutputTypes>
+    ] ? NarrowedInvokeMethod<O, HttpHandlerOptions, Transform<FunctionInputTypes, StreamingBlobPayloadInputTypes | undefined, I>, FunctionOutputTypes> : ClientType[key];
+} & {
+    send<Command>(command: Command, options?: any): Promise<Transform<GetOutputType<Command>, StreamingBlobPayloadOutputTypes | undefined, O>>;
+};

package/node_modules/@smithy/types/dist-types/ts3.4/transform/exact.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Checks that A and B extend each other.
+ *
+ * @internal
+ */
+export type Exact<A, B> = [
+    A
+] extends [
+    B
+] ? ([
+    B
+] extends [
+    A
+] ? true : false) : false;

package/node_modules/@smithy/types/dist-types/ts3.4/transform/mutable.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @internal
+ */
+export type Mutable<Type> = {
+    -readonly [Property in keyof Type]: Type[Property];
+};

package/node_modules/@smithy/types/dist-types/ts3.4/transform/no-undefined.d.ts

@@ -0,0 +1,88 @@
+import { InvokeMethod, InvokeMethodOptionalArgs } from "../client";
+import { GetOutputType } from "../command";
+import { DocumentType } from "../shapes";
+/**
+ * This type is intended as a type helper for generated clients.
+ * When initializing client, cast it to this type by passing
+ * the client constructor type as the type parameter.
+ *
+ * It will then recursively remove "undefined" as a union type from all
+ * input and output shapes' members. Note, this does not affect
+ * any member that is optional (?) such as outputs with no required members.
+ *
+ * @example
+ * ```ts
+ * const client = new Client({}) as AssertiveClient<Client>;
+ * ```
+ *
+ * @public
+ */
+export type AssertiveClient<Client extends object> = NarrowClientIOTypes<Client>;
+/**
+ * This is similar to AssertiveClient but additionally changes all
+ * output types to (recursive) Required<T> so as to bypass all output nullability guards.
+ *
+ * @public
+ */
+export type UncheckedClient<Client extends object> = UncheckedClientOutputTypes<Client>;
+/**
+ * Excludes undefined recursively.
+ *
+ * @internal
+ */
+export type NoUndefined<T> = T extends Function ? T : T extends DocumentType ? T : [
+    T
+] extends [
+    object
+] ? {
+    [key in keyof T]: NoUndefined<T[key]>;
+} : Exclude<T, undefined>;
+/**
+ * Excludes undefined and optional recursively.
+ *
+ * @internal
+ */
+export type RecursiveRequired<T> = T extends Function ? T : T extends DocumentType ? T : [
+    T
+] extends [
+    object
+] ? {
+    [key in keyof T]-?: RecursiveRequired<T[key]>;
+} : Exclude<T, undefined>;
+/**
+ * Removes undefined from unions.
+ *
+ * @internal
+ */
+type NarrowClientIOTypes<ClientType extends object> = {
+    [key in keyof ClientType]: [
+        ClientType[key]
+    ] extends [
+        InvokeMethodOptionalArgs<infer FunctionInputTypes, infer FunctionOutputTypes>
+    ] ? InvokeMethodOptionalArgs<NoUndefined<FunctionInputTypes>, NoUndefined<FunctionOutputTypes>> : [
+        ClientType[key]
+    ] extends [
+        InvokeMethod<infer FunctionInputTypes, infer FunctionOutputTypes>
+    ] ? InvokeMethod<NoUndefined<FunctionInputTypes>, NoUndefined<FunctionOutputTypes>> : ClientType[key];
+} & {
+    send<Command>(command: Command, options?: any): Promise<NoUndefined<GetOutputType<Command>>>;
+};
+/**
+ * Removes undefined from unions and adds yolo output types.
+ *
+ * @internal
+ */
+type UncheckedClientOutputTypes<ClientType extends object> = {
+    [key in keyof ClientType]: [
+        ClientType[key]
+    ] extends [
+        InvokeMethodOptionalArgs<infer FunctionInputTypes, infer FunctionOutputTypes>
+    ] ? InvokeMethodOptionalArgs<NoUndefined<FunctionInputTypes>, RecursiveRequired<FunctionOutputTypes>> : [
+        ClientType[key]
+    ] extends [
+        InvokeMethod<infer FunctionInputTypes, infer FunctionOutputTypes>
+    ] ? InvokeMethod<NoUndefined<FunctionInputTypes>, RecursiveRequired<FunctionOutputTypes>> : ClientType[key];
+} & {
+    send<Command>(command: Command, options?: any): Promise<RecursiveRequired<NoUndefined<GetOutputType<Command>>>>;
+};
+export {};

package/node_modules/@smithy/types/dist-types/ts3.4/transform/type-transform.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Transforms any members of the object T having type FromType
+ * to ToType. This applies only to exact type matches.
+ * This is for the case where FromType is a union and only those fields
+ * matching the same union should be transformed.
+ *
+ * @public
+ */
+export type Transform<T, FromType, ToType> = RecursiveTransformExact<T, FromType, ToType>;
+/**
+ * Returns ToType if T matches exactly with FromType.
+ *
+ * @internal
+ */
+type TransformExact<T, FromType, ToType> = [
+    T
+] extends [
+    FromType
+] ? ([
+    FromType
+] extends [
+    T
+] ? ToType : T) : T;
+/**
+ * Applies TransformExact to members of an object recursively.
+ *
+ * @internal
+ */
+type RecursiveTransformExact<T, FromType, ToType> = T extends Function ? T : T extends object ? {
+    [key in keyof T]: [
+        T[key]
+    ] extends [
+        FromType
+    ] ? [
+        FromType
+    ] extends [
+        T[key]
+    ] ? ToType : RecursiveTransformExact<T[key], FromType, ToType> : RecursiveTransformExact<T[key], FromType, ToType>;
+} : TransformExact<T, FromType, ToType>;
+export {};

package/node_modules/@smithy/types/dist-types/ts3.4/uri.d.ts

@@ -0,0 +1,17 @@
+import { QueryParameterBag } from "./http";
+/**
+ * Represents the components parts of a Uniform Resource Identifier used to
+ * construct the target location of a Request.
+ *
+ * @internal
+ */
+export type URI = {
+    protocol: string;
+    hostname: string;
+    port?: number;
+    path: string;
+    query?: QueryParameterBag;
+    username?: string;
+    password?: string;
+    fragment?: string;
+};

package/node_modules/@smithy/types/dist-types/ts3.4/util.d.ts

@@ -0,0 +1,192 @@
+import { Endpoint } from "./http";
+import { FinalizeHandler, FinalizeHandlerArguments, FinalizeHandlerOutput } from "./middleware";
+import { MetadataBearer } from "./response";
+/**
+ * A generic which checks if Type1 is exactly same as Type2.
+ *
+ * @public
+ */
+export type Exact<Type1, Type2> = [
+    Type1
+] extends [
+    Type2
+] ? ([
+    Type2
+] extends [
+    Type1
+] ? true : false) : false;
+/**
+ * A function that, given a Uint8Array of bytes, can produce a string
+ * representation thereof. The function may optionally attempt to
+ * convert other input types to Uint8Array before encoding.
+ *
+ * @example An encoder function that converts bytes to hexadecimal
+ * representation would return `'hello'` when given
+ * `new Uint8Array([104, 101, 108, 108, 111])`.
+ *
+ * @public
+ */
+export interface Encoder {
+    /**
+     * Caution: the `any` type on the input is for backwards compatibility.
+     * Runtime support is limited to Uint8Array and string by default.
+     *
+     * You may choose to support more encoder input types if overriding the default
+     * implementations.
+     */
+    (input: Uint8Array | string | any): string;
+}
+/**
+ * A function that, given a string, can derive the bytes represented by that
+ * string.
+ *
+ * @example A decoder function that converts bytes to hexadecimal
+ * representation would return `new Uint8Array([104, 101, 108, 108, 111])` when
+ * given the string `'hello'`.
+ *
+ * @public
+ */
+export interface Decoder {
+    (input: string): Uint8Array;
+}
+/**
+ * A function that, when invoked, returns a promise that will be fulfilled with
+ * a value of type T.
+ *
+ * @example A function that reads credentials from shared SDK configuration
+ * files, assuming roles and collecting MFA tokens as necessary.
+ *
+ * @public
+ */
+export interface Provider<T> {
+    (): Promise<T>;
+}
+/**
+ * A tuple that represents an API name and optional version
+ * of a library built using the AWS SDK.
+ *
+ * @public
+ */
+export type UserAgentPair = [
+    /*name*/ string,
+    /*version*/ string
+];
+/**
+ * User agent data that to be put into the request's user
+ * agent.
+ *
+ * @public
+ */
+export type UserAgent = UserAgentPair[];
+/**
+ * Parses a URL in string form into an Endpoint object.
+ *
+ * @public
+ */
+export interface UrlParser {
+    (url: string | URL): Endpoint;
+}
+/**
+ * A function that, when invoked, returns a promise that will be fulfilled with
+ * a value of type T. It memoizes the result from the previous invocation
+ * instead of calling the underlying resources every time.
+ *
+ * You can force the provider to refresh the memoized value by invoke the
+ * function with optional parameter hash with `forceRefresh` boolean key and
+ * value `true`.
+ *
+ * @example A function that reads credentials from IMDS service that could
+ * return expired credentials. The SDK will keep using the expired credentials
+ * until an unretryable service error requiring a force refresh of the
+ * credentials.
+ *
+ * @public
+ */
+export interface MemoizedProvider<T> {
+    (options?: {
+        forceRefresh?: boolean;
+    }): Promise<T>;
+}
+/**
+ * A function that, given a request body, determines the
+ * length of the body. This is used to determine the Content-Length
+ * that should be sent with a request.
+ *
+ * @example A function that reads a file stream and calculates
+ * the size of the file.
+ *
+ * @public
+ */
+export interface BodyLengthCalculator {
+    (body: any): number | undefined;
+}
+/**
+ * Object containing regionalization information of
+ * AWS services.
+ *
+ * @public
+ */
+export interface RegionInfo {
+    hostname: string;
+    partition: string;
+    path?: string;
+    signingService?: string;
+    signingRegion?: string;
+}
+/**
+ * Options to pass when calling {@link RegionInfoProvider}
+ *
+ * @public
+ */
+export interface RegionInfoProviderOptions {
+    /**
+     * Enables IPv6/IPv4 dualstack endpoint.
+     * @defaultValue false
+     */
+    useDualstackEndpoint: boolean;
+    /**
+     * Enables FIPS compatible endpoints.
+     * @defaultValue false
+     */
+    useFipsEndpoint: boolean;
+}
+/**
+ * Function returns designated service's regionalization
+ * information from given region. Each service client
+ * comes with its regionalization provider. it serves
+ * to provide the default values of related configurations
+ *
+ * @public
+ */
+export interface RegionInfoProvider {
+    (region: string, options?: RegionInfoProviderOptions): Promise<RegionInfo | undefined>;
+}
+/**
+ * Interface that specifies the retry behavior
+ *
+ * @public
+ */
+export interface RetryStrategy {
+    /**
+     * The retry mode describing how the retry strategy control the traffic flow.
+     */
+    mode?: string;
+    /**
+     * the retry behavior the will invoke the next handler and handle the retry accordingly.
+     * This function should also update the $metadata from the response accordingly.
+     * @see {@link ResponseMetadata}
+     */
+    retry: <Input extends object, Output extends MetadataBearer>(next: FinalizeHandler<Input, Output>, args: FinalizeHandlerArguments<Input>) => Promise<FinalizeHandlerOutput<Output>>;
+}
+/**
+ * Indicates the parameter may be omitted if the parameter object T
+ * is equivalent to a Partial<T>, i.e. all properties optional.
+ *
+ * @public
+ */
+export type OptionalParameter<T> = Exact<Partial<T>, T> extends true ? [
+] | [
+    T
+] : [
+    T
+];

package/node_modules/@smithy/types/dist-types/ts3.4/waiter.d.ts

@@ -0,0 +1,35 @@
+import { AbortController as DeprecatedAbortController } from "./abort";
+/**
+ * @public
+ */
+export interface WaiterConfiguration<Client> {
+    /**
+     * Required service client
+     */
+    client: Client;
+    /**
+     * The amount of time in seconds a user is willing to wait for a waiter to complete.
+     */
+    maxWaitTime: number;
+    /**
+     * @deprecated Use abortSignal
+     * Abort controller. Used for ending the waiter early.
+     */
+    abortController?: AbortController | DeprecatedAbortController;
+    /**
+     * Abort Signal. Used for ending the waiter early.
+     */
+    abortSignal?: AbortController["signal"] | DeprecatedAbortController["signal"];
+    /**
+     * The minimum amount of time to delay between retries in seconds. This is the
+     * floor of the exponential backoff. This value defaults to service default
+     * if not specified. This value MUST be less than or equal to maxDelay and greater than 0.
+     */
+    minDelay?: number;
+    /**
+     * The maximum amount of time to delay between retries in seconds. This is the
+     * ceiling of the exponential backoff. This value defaults to service default
+     * if not specified. If specified, this value MUST be greater than or equal to 1.
+     */
+    maxDelay?: number;
+}

package/node_modules/@smithy/types/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smithy/types",
-  "version": "4.16.0",
+  "version": "4.16.1",
   "scripts": {
     "build": "concurrently 'yarn:build:types' 'yarn:build:es:cjs'",
     "build:es:cjs": "premove dist-es && yarn g:tsc -p tsconfig.es.json && node ../../scripts/inline",
@@ -36,7 +36,7 @@
     "node": ">=18.0.0"
   },
   "typesVersions": {
-    "<=4.0": {
+    "<=4.5": {
       "dist-types/*": [
         "dist-types/ts3.4/*"
       ]

package/node_modules/ws/lib/receiver.js

@@ -77,6 +77,7 @@ class Receiver extends Writable {
 
     this._totalPayloadLength = 0;
     this._messageLength = 0;
+    this._numFragments = 0;
     this._fragments = [];
 
     this._errored = false;
@@ -500,6 +501,19 @@ class Receiver extends Writable {
       return;
     }
 
+    if (this._maxFragments > 0 && ++this._numFragments > this._maxFragments) {
+      const error = this.createError(
+        RangeError,
+        'Too many message fragments',
+        false,
+        1008,
+        'WS_ERR_TOO_MANY_BUFFERED_PARTS'
+      );
+
+      cb(error);
+      return;
+    }
+
     if (this._compressed) {
       this._state = INFLATING;
       this.decompress(data, cb);
@@ -507,22 +521,6 @@ class Receiver extends Writable {
     }
 
     if (data.length) {
-      if (
-        this._maxFragments > 0 &&
-        this._fragments.length >= this._maxFragments
-      ) {
-        const error = this.createError(
-          RangeError,
-          'Too many message fragments',
-          false,
-          1008,
-          'WS_ERR_TOO_MANY_BUFFERED_PARTS'
-        );
-
-        cb(error);
-        return;
-      }
-
       //
       // This message is not compressed so its length is the sum of the payload
       // length of all fragments.
@@ -562,22 +560,6 @@ class Receiver extends Writable {
           return;
         }
 
-        if (
-          this._maxFragments > 0 &&
-          this._fragments.length >= this._maxFragments
-        ) {
-          const error = this.createError(
-            RangeError,
-            'Too many message fragments',
-            false,
-            1008,
-            'WS_ERR_TOO_MANY_BUFFERED_PARTS'
-          );
-
-          cb(error);
-          return;
-        }
-
         this._fragments.push(buf);
       }
 
@@ -604,6 +586,7 @@ class Receiver extends Writable {
     this._totalPayloadLength = 0;
     this._messageLength = 0;
     this._fragmented = 0;
+    this._numFragments = 0;
     this._fragments = [];
 
     if (this._opcode === 2) {

package/node_modules/ws/lib/websocket-server.js

@@ -43,9 +43,9 @@ class WebSocketServer extends EventEmitter {
    *     called
    * @param {Function} [options.handleProtocols] A hook to handle protocols
    * @param {String} [options.host] The hostname where to bind the server
-   * @param {Number} [options.maxBufferedChunks=1048576] The maximum number of
+   * @param {Number} [options.maxBufferedChunks=262144] The maximum number of
    *     buffered data chunks
-   * @param {Number} [options.maxFragments=131072] The maximum number of message
+   * @param {Number} [options.maxFragments=16384] The maximum number of message
    *     fragments
    * @param {Number} [options.maxPayload=104857600] The maximum allowed message
    *     size
@@ -69,8 +69,8 @@ class WebSocketServer extends EventEmitter {
     options = {
       allowSynchronousEvents: true,
       autoPong: true,
-      maxBufferedChunks: 1024 * 1024,
-      maxFragments: 128 * 1024,
+      maxBufferedChunks: 256 * 1024,
+      maxFragments: 16 * 1024,
       maxPayload: 100 * 1024 * 1024,
       skipUTF8Validation: false,
       perMessageDeflate: false,