@psnext/slingcli 3.0.20260827-1 → 3.3.20260911-1

package/node_modules/undici-types/readable.d.ts

@@ -1,47 +1,45 @@
-import { Readable } from 'node:stream'
-import { Blob } from 'node:buffer'
+import { Readable } from "stream";
+import { Blob } from 'buffer'
 
 export default BodyReadable
 
 declare class BodyReadable extends Readable {
-  constructor (opts: {
-    resume: (this: Readable, size: number) => void | null;
-    abort: () => void | null;
-    contentType?: string;
-    contentLength?: number;
-    highWaterMark?: number;
-  })
+  constructor(
+    resume?: (this: Readable, size: number) => void | null,
+    abort?: () => void | null,
+    contentType?: string
+  )
 
   /** Consumes and returns the body as a string
    *  https://fetch.spec.whatwg.org/#dom-body-text
    */
-  text (): Promise<string>
+  text(): Promise<string>
 
   /** Consumes and returns the body as a JavaScript Object
    *  https://fetch.spec.whatwg.org/#dom-body-json
    */
-  json (): Promise<unknown>
+  json(): Promise<unknown>
 
   /** Consumes and returns the body as a Blob
    *  https://fetch.spec.whatwg.org/#dom-body-blob
    */
-  blob (): Promise<Blob>
+  blob(): Promise<Blob>
 
   /** Consumes and returns the body as an Uint8Array
    *  https://fetch.spec.whatwg.org/#dom-body-bytes
    */
-  bytes (): Promise<Uint8Array>
+  bytes(): Promise<Uint8Array>
 
   /** Consumes and returns the body as an ArrayBuffer
    *  https://fetch.spec.whatwg.org/#dom-body-arraybuffer
    */
-  arrayBuffer (): Promise<ArrayBuffer>
+  arrayBuffer(): Promise<ArrayBuffer>
 
   /** Not implemented
    *
    *  https://fetch.spec.whatwg.org/#dom-body-formdata
    */
-  formData (): Promise<never>
+  formData(): Promise<never>
 
   /** Returns true if the body is not null and the body has been consumed
    *
@@ -51,7 +49,7 @@ declare class BodyReadable extends Readable {
    */
   readonly bodyUsed: boolean
 
-  /**
+  /** 
    * If body is null, it should return null as the body
    *
    *  If body is not null, should return the body as a ReadableStream
@@ -61,8 +59,7 @@ declare class BodyReadable extends Readable {
   readonly body: never | undefined
 
   /** Dumps the response body by reading `limit` number of bytes.
-   * @param opts.limit Number of bytes to read (optional) - Default: 131072
-   * @param opts.signal AbortSignal to cancel the operation (optional)
+   * @param opts.limit Number of bytes to read (optional) - Default: 262144
    */
-  dump (opts?: { limit: number; signal?: AbortSignal }): Promise<void>
+  dump(opts?: { limit: number }): Promise<void>
 }

package/node_modules/undici-types/retry-agent.d.ts

@@ -4,5 +4,5 @@ import RetryHandler from './retry-handler'
 export default RetryAgent
 
 declare class RetryAgent extends Dispatcher {
-  constructor (dispatcher: Dispatcher, options?: RetryHandler.RetryOptions)
+  constructor(dispatcher: Dispatcher, options?: RetryHandler.RetryOptions)
 }

package/node_modules/undici-types/retry-handler.d.ts

@@ -1,18 +1,18 @@
-import Dispatcher from './dispatcher'
+import Dispatcher from "./dispatcher";
 
-export default RetryHandler
+export default RetryHandler;
 
-declare class RetryHandler implements Dispatcher.DispatchHandler {
-  constructor (
+declare class RetryHandler implements Dispatcher.DispatchHandlers {
+  constructor(
     options: Dispatcher.DispatchOptions & {
       retryOptions?: RetryHandler.RetryOptions;
     },
     retryHandlers: RetryHandler.RetryHandlers
-  )
+  );
 }
 
 declare namespace RetryHandler {
-  export type RetryState = { counter: number; }
+  export type RetryState = { counter: number; };
 
   export type RetryContext = {
     state: RetryState;
@@ -21,7 +21,7 @@ declare namespace RetryHandler {
     };
   }
 
-  export type OnRetryCallback = (result?: Error | null) => void
+  export type OnRetryCallback = (result?: Error | null) => void;
 
   export type RetryCallback = (
     err: Error,
@@ -32,18 +32,9 @@ declare namespace RetryHandler {
       };
     },
     callback: OnRetryCallback
-  ) => void
+  ) => number | null;
 
   export interface RetryOptions {
-    /**
-     * If true, the retry handler will throw an error if the request fails,
-     * this will prevent the folling handlers from being called, and will destroy the socket.
-     *
-     * @type {boolean}
-     * @memberof RetryOptions
-     * @default true
-     */
-    throwOnError?: boolean;
     /**
      * Callback to be invoked on every retry iteration.
      * It receives the error, current state of the retry object and the options object
@@ -119,7 +110,7 @@ declare namespace RetryHandler {
   }
 
   export interface RetryHandlers {
-    dispatch: Dispatcher['dispatch'];
-    handler: Dispatcher.DispatchHandler;
+    dispatch: Dispatcher["dispatch"];
+    handler: Dispatcher.DispatchHandlers;
   }
 }

package/node_modules/undici-types/util.d.ts

@@ -3,7 +3,7 @@ export namespace util {
    * Retrieves a header name and returns its lowercase value.
    * @param value Header name
    */
-  export function headerNameToString (value: string | Buffer): string
+  export function headerNameToString(value: string | Buffer): string;
 
   /**
    * Receives a header object and returns the parsed value.
@@ -11,8 +11,8 @@ export namespace util {
    * @param obj Object to specify a proxy object. Used to assign parsed values.
    * @returns If `obj` is specified, it is equivalent to `obj`.
    */
-  export function parseHeaders (
+  export function parseHeaders(
     headers: (Buffer | string | (Buffer | string)[])[],
     obj?: Record<string, string | string[]>
-  ): Record<string, string | string[]>
+  ): Record<string, string | string[]>;
 }

package/node_modules/undici-types/webidl.d.ts

@@ -1,6 +1,4 @@
 // These types are not exported, and are only used internally
-import { BufferSource } from 'node:stream/web'
-import * as undici from './index'
 
 /**
  * Take in an unknown value and return one that is of type T
@@ -11,13 +9,15 @@ type SequenceConverter<T> = (object: unknown, iterable?: IterableIterator<T>) =>
 
 type RecordConverter<K extends string, V> = (object: unknown) => Record<K, V>
 
+interface ConvertToIntOpts {
+  clamp?: boolean
+  enforceRange?: boolean
+}
+
 interface WebidlErrors {
-  /**
-   * @description Instantiate an error
-   */
   exception (opts: { header: string, message: string }): TypeError
   /**
-   * @description Instantiate an error when conversion from one type to another has failed
+   * @description Throw an error when conversion from one type to another has failed
    */
   conversionFailed (opts: {
     prefix: string
@@ -34,24 +34,11 @@ interface WebidlErrors {
   }): TypeError
 }
 
-interface WebIDLTypes {
-  UNDEFINED: 1,
-  BOOLEAN: 2,
-  STRING: 3,
-  SYMBOL: 4,
-  NUMBER: 5,
-  BIGINT: 6,
-  NULL: 7
-  OBJECT: 8
-}
-
 interface WebidlUtil {
   /**
    * @see https://tc39.es/ecma262/#sec-ecmascript-data-types-and-values
    */
-  Type (object: unknown): WebIDLTypes[keyof WebIDLTypes]
-
-  TypeValueToString (o: unknown):
+  Type (object: unknown):
     | 'Undefined'
     | 'Boolean'
     | 'String'
@@ -61,8 +48,6 @@ interface WebidlUtil {
     | 'Null'
     | 'Object'
 
-  Types: WebIDLTypes
-
   /**
    * @see https://webidl.spec.whatwg.org/#abstract-opdef-converttoint
    */
@@ -70,11 +55,11 @@ interface WebidlUtil {
     V: unknown,
     bitLength: number,
     signedness: 'signed' | 'unsigned',
-    flags?: number
+    opts?: ConvertToIntOpts
   ): number
 
   /**
-   * @see https://webidl.spec.whatwg.org/#abstract-opdef-integerpart
+   * @see https://webidl.spec.whatwg.org/#abstract-opdef-converttoint
    */
   IntegerPart (N: number): number
 
@@ -83,28 +68,20 @@ interface WebidlUtil {
    */
   Stringify (V: any): string
 
-  MakeTypeAssertion <I>(I: I): (arg: any) => arg is I
-
   /**
    * Mark a value as uncloneable for Node.js.
+   * This is only effective in some newer Node.js versions.
    */
   markAsUncloneable (V: any): void
-
-  IsResizableArrayBuffer (V: ArrayBufferLike): boolean
-
-  HasFlag (flag: number, attributes: number): boolean
-
-  /**
-   * @see https://webidl.spec.whatwg.org/#dfn-get-buffer-source-copy
-   */
-  getCopyOfBytesHeldByBufferSource (bufferSource: BufferSource): Uint8Array
 }
 
 interface WebidlConverters {
   /**
    * @see https://webidl.spec.whatwg.org/#es-DOMString
    */
-  DOMString (V: unknown, prefix: string, argument: string, flags?: number): string
+  DOMString (V: unknown, prefix: string, argument: string, opts?: {
+    legacyNullToEmptyString: boolean
+  }): string
 
   /**
    * @see https://webidl.spec.whatwg.org/#es-ByteString
@@ -144,140 +121,59 @@ interface WebidlConverters {
   /**
    * @see https://webidl.spec.whatwg.org/#es-unsigned-short
    */
-  ['unsigned short'] (V: unknown, flags?: number): number
+  ['unsigned short'] (V: unknown, opts?: ConvertToIntOpts): number
 
   /**
    * @see https://webidl.spec.whatwg.org/#idl-ArrayBuffer
    */
-  ArrayBuffer (
-    V: unknown,
-    prefix: string,
-    argument: string,
-    options?: { allowResizable: boolean }
-  ): ArrayBuffer
-
-  /**
-   * @see https://webidl.spec.whatwg.org/#idl-SharedArrayBuffer
-   */
-  SharedArrayBuffer (
-    V: unknown,
-    prefix: string,
-    argument: string,
-    options?: { allowResizable: boolean }
-  ): SharedArrayBuffer
+  ArrayBuffer (V: unknown): ArrayBufferLike
+  ArrayBuffer (V: unknown, opts: { allowShared: false }): ArrayBuffer
 
   /**
    * @see https://webidl.spec.whatwg.org/#es-buffer-source-types
    */
   TypedArray (
     V: unknown,
-    T: new () => NodeJS.TypedArray,
-    prefix: string,
-    argument: string,
-    flags?: number
-  ): NodeJS.TypedArray
-
-  /**
-   * @see https://webidl.spec.whatwg.org/#es-buffer-source-types
-   */
-  DataView (
+    TypedArray: NodeJS.TypedArray | ArrayBufferLike
+  ): NodeJS.TypedArray | ArrayBufferLike
+  TypedArray (
     V: unknown,
-    prefix: string,
-    argument: string,
-    flags?: number
-  ): DataView
+    TypedArray: NodeJS.TypedArray | ArrayBufferLike,
+    opts?: { allowShared: false }
+  ): NodeJS.TypedArray | ArrayBuffer
 
   /**
    * @see https://webidl.spec.whatwg.org/#es-buffer-source-types
    */
-  ArrayBufferView (
-    V: unknown,
-    prefix: string,
-    argument: string,
-    flags?: number
-  ): NodeJS.ArrayBufferView
+  DataView (V: unknown, opts?: { allowShared: boolean }): DataView
 
   /**
    * @see https://webidl.spec.whatwg.org/#BufferSource
    */
   BufferSource (
     V: unknown,
-    prefix: string,
-    argument: string,
-    flags?: number
-  ): ArrayBuffer | NodeJS.ArrayBufferView
-
-  /**
-   * @see https://webidl.spec.whatwg.org/#AllowSharedBufferSource
-   */
-  AllowSharedBufferSource (
-    V: unknown,
-    prefix: string,
-    argument: string,
-    flags?: number
-  ): ArrayBuffer | SharedArrayBuffer | NodeJS.ArrayBufferView
+    opts?: { allowShared: boolean }
+  ): NodeJS.TypedArray | ArrayBufferLike | DataView
 
   ['sequence<ByteString>']: SequenceConverter<string>
-
+  
   ['sequence<sequence<ByteString>>']: SequenceConverter<string[]>
 
   ['record<ByteString, ByteString>']: RecordConverter<string, string>
 
-  /**
-  * @see https://fetch.spec.whatwg.org/#requestinfo
-  */
-  RequestInfo (V: unknown): undici.Request | string
-
-  /**
-   * @see https://fetch.spec.whatwg.org/#requestinit
-   */
-  RequestInit (V: unknown): undici.RequestInit
-
-  /**
-   * @see https://html.spec.whatwg.org/multipage/webappapis.html#eventhandlernonnull
-   */
-  EventHandlerNonNull (V: unknown): Function | null
-
-  WebSocketStreamWrite (V: unknown): ArrayBuffer | NodeJS.TypedArray | string
-
   [Key: string]: (...args: any[]) => unknown
 }
 
-type WebidlIsFunction<T> = (arg: any) => arg is T
-
-interface WebidlIs {
-  Request: WebidlIsFunction<undici.Request>
-  Response: WebidlIsFunction<undici.Response>
-  ReadableStream: WebidlIsFunction<ReadableStream>
-  Blob: WebidlIsFunction<Blob>
-  URLSearchParams: WebidlIsFunction<URLSearchParams>
-  File: WebidlIsFunction<File>
-  FormData: WebidlIsFunction<undici.FormData>
-  URL: WebidlIsFunction<URL>
-  WebSocketError: WebidlIsFunction<undici.WebSocketError>
-  AbortSignal: WebidlIsFunction<AbortSignal>
-  MessagePort: WebidlIsFunction<MessagePort>
-  USVString: WebidlIsFunction<string>
-  /**
-   * @see https://webidl.spec.whatwg.org/#BufferSource
-   */
-  BufferSource: WebidlIsFunction<ArrayBuffer | NodeJS.TypedArray>
-}
-
 export interface Webidl {
   errors: WebidlErrors
   util: WebidlUtil
   converters: WebidlConverters
-  is: WebidlIs
-  attributes: WebIDLExtendedAttributes
 
   /**
    * @description Performs a brand-check on {@param V} to ensure it is a
    * {@param cls} object.
    */
-  brandCheck <Interface extends new () => unknown>(V: unknown, cls: Interface): asserts V is Interface
-
-  brandCheckMultiple <Interfaces extends (new () => unknown)[]> (list: Interfaces): (V: any) => asserts V is Interfaces[number]
+  brandCheck <Interface>(V: unknown, cls: Interface, opts?: { strict?: boolean }): asserts V is Interface
 
   /**
    * @see https://webidl.spec.whatwg.org/#es-sequence
@@ -300,11 +196,10 @@ export interface Webidl {
    * Similar to {@link Webidl.brandCheck} but allows skipping the check if third party
    * interfaces are allowed.
    */
-  interfaceConverter <Interface>(typeCheck: WebidlIsFunction<Interface>, name: string): (
+  interfaceConverter <Interface>(cls: Interface): (
     V: unknown,
-    prefix: string,
-    argument: string
-  ) => asserts V is Interface
+    opts?: { strict: boolean }
+  ) => asserts V is typeof cls
 
   // TODO(@KhafraDev): a type could likely be implemented that can infer the return type
   // from the converters given?
@@ -331,16 +226,3 @@ export interface Webidl {
 
   argumentLengthCheck (args: { length: number }, min: number, context: string): void
 }
-
-interface WebIDLExtendedAttributes {
-  /** https://webidl.spec.whatwg.org/#Clamp */
-  Clamp: number
-  /** https://webidl.spec.whatwg.org/#EnforceRange */
-  EnforceRange: number
-  /** https://webidl.spec.whatwg.org/#AllowShared */
-  AllowShared: number
-  /** https://webidl.spec.whatwg.org/#AllowResizable */
-  AllowResizable: number
-  /** https://webidl.spec.whatwg.org/#LegacyNullToEmptyString */
-  LegacyNullToEmptyString: number
-}

package/node_modules/undici-types/websocket.d.ts

@@ -1,8 +1,7 @@
 /// <reference types="node" />
 
-import type { Blob } from 'node:buffer'
-import type { ReadableStream, WritableStream } from 'node:stream/web'
-import type { MessagePort } from 'node:worker_threads'
+import type { Blob } from 'buffer'
+import type { MessagePort } from 'worker_threads'
 import {
   EventInit,
   EventListenerOptions,
@@ -23,7 +22,7 @@ interface WebSocketEventMap {
 
 interface WebSocket extends EventTarget {
   binaryType: BinaryType
-
+  
   readonly bufferedAmount: number
   readonly extensions: string
 
@@ -96,16 +95,16 @@ interface MessageEventInit<T = any> extends EventInit {
   data?: T
   lastEventId?: string
   origin?: string
-  ports?: MessagePort[]
-  source?: MessagePort | null
+  ports?: (typeof MessagePort)[]
+  source?: typeof MessagePort | null
 }
 
 interface MessageEvent<T = any> extends Event {
   readonly data: T
   readonly lastEventId: string
   readonly origin: string
-  readonly ports: readonly MessagePort[]
-  readonly source: MessagePort | null
+  readonly ports: ReadonlyArray<typeof MessagePort>
+  readonly source: typeof MessagePort | null
   initMessageEvent(
     type: string,
     bubbles?: boolean,
@@ -113,8 +112,8 @@ interface MessageEvent<T = any> extends Event {
     data?: any,
     origin?: string,
     lastEventId?: string,
-    source?: MessagePort | null,
-    ports?: MessagePort[]
+    source?: typeof MessagePort | null,
+    ports?: (typeof MessagePort)[]
   ): void;
 }
 
@@ -136,7 +135,7 @@ interface ErrorEvent extends Event {
   readonly filename: string
   readonly lineno: number
   readonly colno: number
-  readonly error: Error
+  readonly error: any
 }
 
 export declare const ErrorEvent: {
@@ -149,40 +148,3 @@ interface WebSocketInit {
   dispatcher?: Dispatcher,
   headers?: HeadersInit
 }
-
-interface WebSocketStreamOptions {
-  protocols?: string | string[]
-  signal?: AbortSignal
-}
-
-interface WebSocketCloseInfo {
-  closeCode: number
-  reason: string
-}
-
-interface WebSocketStream {
-  closed: Promise<WebSocketCloseInfo>
-  opened: Promise<{
-    extensions: string
-    protocol: string
-    readable: ReadableStream
-    writable: WritableStream
-  }>
-  url: string
-
-  close(options?: Partial<WebSocketCloseInfo>): void
-}
-
-export declare const WebSocketStream: {
-  prototype: WebSocketStream
-  new (url: string | URL, options?: WebSocketStreamOptions): WebSocketStream
-}
-
-interface WebSocketError extends Event, WebSocketCloseInfo {}
-
-export declare const WebSocketError: {
-  prototype: WebSocketError
-  new (type: string, init?: WebSocketCloseInfo): WebSocketError
-}
-
-export declare const ping: (ws: WebSocket, body?: Buffer) => void

package/node_modules/zod/README.md

@@ -113,6 +113,33 @@ await schema.parseAsync("hello");
 // => "hello"
 ```
 
+### AOT compilation
+
+For hot validation paths, `z.compile(schema)` returns a schema clone with an ahead-of-time compiled fast path. Valid inputs take the compiled path; invalid inputs fall back to the regular parser so error reporting stays identical.
+
+Across a 55-schema benchmark the median speedup is **2.4x**, and it scales with how much work the schema does per parse: a large array of objects is ~9x, a 20-key object ~9x, a nested object ~4.5x, while a bare `z.string()` gains nothing — compilation removes per-node dispatch and allocation, and a single `typeof` has none to remove.
+
+```ts
+const CompiledPlayer = z.compile(Player);
+
+CompiledPlayer.parse({ username: "billie", xp: 100 });
+```
+
+To enable compilation globally for schemas constructed after import:
+
+```ts
+import "zod/compile"; // place before modules that define schemas
+```
+
+Things to know:
+
+- Compilation uses `new Function`. Global mode is automatically disabled when `z.config({ jitless: true })` is set (e.g. CSP environments); calling `z.compile()` directly is an explicit opt-in.
+- Schemas with async refinements or transforms can't be compiled, and neither can a few other constructs. That is not an error: `z.compile()` hands the schema back unchanged and it keeps using the regular parser, exactly as global mode leaves it. Pass `{ strict: true }` to throw `ZodCompileAsyncError` / `ZodCompileUnsupportedError` instead.
+- On invalid input, refinements and transforms may run twice (fast path, then fallback).
+- Deriving a new schema from a compiled one (`.refine()`, `.extend()`, etc.) returns an uncompiled schema — compile the final schema.
+
+See [`compile` docs](https://zod.dev/compile) for details.
+
 ### Handling errors
 
 When validation fails, the `.parse()` method will throw a `ZodError` instance with granular information about the validation issues.