vovk 3.7.0 → 4.0.0-beta.0

package/dist/tools/derive-tools.js

@@ -1,5 +1,9 @@
-import { ToModelOutput } from './to-model-output.js';
+import { jsonSchemasObjectToSingleJSONSchemaOnlySpec, jsonSchemaToJSONSchemaOnlySpec, } from '../validation/json-schema-only-spec.js';
 import { validationSchemasObjectToSingleValidationSchema } from '../validation/validation-schemas-object-to-single-validation-schema.js';
+import { ToModelOutput } from './to-model-output.js';
+function isAsyncIterable(value) {
+    return typeof value?.[Symbol.asyncIterator] === 'function';
+}
 async function caller({ handler, handlerName, body, query, params, meta, toModelOutput }, tool) {
     if (!handler.isRPC && !handler.fn) {
         throw new Error('Handler is not a valid RPC or controller method');
@@ -28,10 +32,26 @@ async function caller({ handler, handlerName, body, query, params, meta, toModel
         else {
             throw new Error(`Unable to call handler "${handlerName}". It's neither RPC nor controller method with "fn" interface.`);
         }
-        return [await toModelOutput(result, tool, req), req];
+        // a streaming handler yields its items, collect them so the model sees data instead of an iterator
+        if (isAsyncIterable(result)) {
+            const items = [];
+            for await (const item of result)
+                items.push(item);
+            result = items;
+        }
+        return [
+            await toModelOutput(result, tool, req),
+            req,
+            null,
+        ];
     }
     catch (e) {
-        return [await toModelOutput(e, tool, null), null];
+        // report the error separately, the formatted output is never an Error instance
+        return [
+            await toModelOutput(e, tool, null),
+            null,
+            e,
+        ];
     }
 }
 const makeTool = ({ moduleName, handlerName, module, meta, toModelOutput, onExecute, onError, }) => {
@@ -43,16 +63,25 @@ const makeTool = ({ moduleName, handlerName, module, meta, toModelOutput, onExec
         throw new Error(`Handler "${handlerName}" not found in module "${moduleName}".`);
     }
     const { schema, definition } = handler;
+    const name = schema?.operationObject?.['x-tool']?.name ?? `${moduleName}_${handlerName}`;
     const inputSchemas = Object.fromEntries(['body', 'query', 'params'].map((key) => [key, definition?.[key]]).filter(([, value]) => Boolean(value)));
-    const inputSchema = Object.keys(inputSchemas).length > 0 ? validationSchemasObjectToSingleValidationSchema(inputSchemas) : undefined;
-    if (!schema?.operationObject) {
-        throw new Error(`Handler "${handlerName}" in module "${moduleName}" does not have a valid schema.`);
-    }
+    // prefer real Standard Schemas from `definition` (procedures); RPC modules only have JSON Schemas
+    // in `schema.validation`, so wrap those (envelope-only validate, see json-schema-only-spec.ts)
+    const inputSchema = Object.keys(inputSchemas).length > 0
+        ? validationSchemasObjectToSingleValidationSchema(inputSchemas)
+        : jsonSchemasObjectToSingleJSONSchemaOnlySpec({
+            schemas: {
+                body: schema?.validation?.body,
+                query: schema?.validation?.query,
+                params: schema?.validation?.params,
+            },
+        });
+    const outputSchema = definition?.output ??
+        (schema?.validation?.output ? jsonSchemaToJSONSchemaOnlySpec({ jsonSchema: schema.validation.output }) : undefined);
     const execute = async (input) => {
         const { body, query, params } = input;
         const callerInput = {
             schema,
-            inputSchemas,
             handler,
             body,
             query,
@@ -62,55 +91,32 @@ const makeTool = ({ moduleName, handlerName, module, meta, toModelOutput, onExec
             moduleName,
             toModelOutput,
         };
-        const [result, req] = await caller(callerInput, tool);
-        if (result instanceof Error) {
-            onError(result, tool, req);
+        const [result, req, error] = await caller(callerInput, tool);
+        if (error) {
+            onError(error, tool, req);
         }
         else {
             onExecute(result, tool, req);
         }
         return result;
     };
-    const parametersProperties = {
-        ...(schema?.validation?.body
-            ? {
-                body: schema.validation.body,
-            }
-            : {}),
-        ...(schema?.validation?.query
-            ? {
-                query: schema.validation.query,
-            }
-            : {}),
-        ...(schema?.validation?.params
-            ? {
-                params: schema.validation.params,
-            }
-            : {}),
-    };
     const tool = {
-        type: 'function',
         execute,
-        name: schema.operationObject?.['x-tool']?.name ?? `${moduleName}_${handlerName}`,
+        name,
         inputSchema: inputSchema,
-        outputSchema: definition?.output,
-        title: schema.operationObject?.['x-tool']?.title ?? schema.operationObject?.summary,
-        description: schema.operationObject?.['x-tool']?.description ??
-            ([schema.operationObject?.summary ?? '', schema.operationObject?.description ?? ''].filter(Boolean).join('\n') ||
+        outputSchema: outputSchema,
+        title: schema?.operationObject?.['x-tool']?.title ?? schema?.operationObject?.summary,
+        description: schema?.operationObject?.['x-tool']?.description ??
+            ([schema?.operationObject?.summary ?? '', schema?.operationObject?.description ?? '']
+                .filter(Boolean)
+                .join('\n') ||
                 handlerName),
-        parameters: {
-            type: 'object',
-            properties: parametersProperties,
-            required: Object.keys(parametersProperties),
-            additionalProperties: false,
-        },
-        inputSchemas,
     };
     return tool;
 };
 export function deriveTools(options) {
     const { modules, meta, toModelOutput = ToModelOutput.DEFAULT, onExecute = (result) => result, onError = () => { }, } = options;
-    const tools = Object.entries(modules ?? {}).flatMap(([moduleName, module]) => {
+    return Object.entries(modules ?? {}).flatMap(([moduleName, module]) => {
         return Object.entries(module ?? {})
             .filter(([, handler]) => handler?.schema?.operationObject && !handler?.schema?.operationObject?.['x-tool']?.hidden)
             .map(([handlerName]) => makeTool({
@@ -123,9 +129,4 @@ export function deriveTools(options) {
             onError,
         }));
     });
-    const toolsByName = Object.fromEntries(tools.map((tool) => [tool.name, tool]));
-    return {
-        tools,
-        toolsByName,
-    };
 }

package/dist/tools/to-model-output-default.d.ts

@@ -1,7 +1,7 @@
 import type { VovkRequest } from '../types/request.js';
-import type { VovkTool } from '../types/tools.js';
+import type { StandardToolV0 } from '../types/standard-tool.js';
 export type DefaultModelOutput<T> = T | {
     error: string;
 };
-export type ToModelOutputDefaultFn = <TInput, TOutput>(result: TOutput | Error, tool: VovkTool<TInput, TOutput, unknown>, req: Pick<VovkRequest, 'vovk'> | null) => DefaultModelOutput<TOutput>;
+export type ToModelOutputDefaultFn = <TInput, TOutput>(result: TOutput | Error, tool: StandardToolV0<TInput, TOutput, unknown>, req: Pick<VovkRequest, 'vovk'> | null) => Promise<DefaultModelOutput<TOutput>>;
 export declare const toModelOutputDefault: ToModelOutputDefaultFn;

package/dist/tools/to-model-output-default.js

@@ -1,7 +1,21 @@
-export const toModelOutputDefault = (result, 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-_tool, 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-_req) => {
-    return result instanceof Error ? { error: result.message } : result;
+const toBase64 = (buf) => typeof Buffer !== 'undefined'
+    ? Buffer.from(buf).toString('base64')
+    : btoa([...new Uint8Array(buf)].map((b) => String.fromCharCode(b)).join(''));
+// a Response has no enumerable keys, so handing it to an SDK would serialize it as {} and leave the body unread
+async function responseToData(res) {
+    const mimeType = res.headers.get('Content-Type')?.split(';')[0].trim() || '';
+    if (mimeType === 'application/json' || mimeType.endsWith('+json')) {
+        return res.json();
+    }
+    if (mimeType.startsWith('text/') || /xml|javascript|yaml/.test(mimeType)) {
+        return res.text();
+    }
+    return { mimeType, data: toBase64(await res.arrayBuffer()) };
+}
+export const toModelOutputDefault = async (result, _tool, _req) => {
+    if (result instanceof Error)
+        return { error: result.message };
+    if (result instanceof Response)
+        return (await responseToData(result));
+    return result;
 };

package/dist/tools/to-model-output-mcp.d.ts

@@ -1,5 +1,6 @@
 import type { VovkRequest } from '../types/request.js';
-import type { VovkTool } from '../types/tools.js';
+import type { StandardToolV0 } from '../types/standard-tool.js';
+import type { KnownAny } from '../types/utils.js';
 export type MCPModelOutput = {
     content: [
         {
@@ -25,6 +26,6 @@ export type MCPModelOutput = {
     };
     isError?: boolean;
 };
-type ToModelOutputMCPFn = <TOutput>(result: TOutput | Error, tool: VovkTool, req: Pick<VovkRequest, 'vovk'> | null) => Promise<MCPModelOutput>;
+type ToModelOutputMCPFn = <TOutput>(result: TOutput | Error, tool: StandardToolV0<KnownAny, KnownAny, KnownAny>, req: Pick<VovkRequest, 'vovk'> | null) => Promise<MCPModelOutput>;
 export declare const toModelOutputMCP: ToModelOutputMCPFn;
 export {};

package/dist/tools/to-model-output.d.ts

@@ -4,5 +4,5 @@
  */
 export declare const ToModelOutput: {
     readonly DEFAULT: import("./to-model-output-default.js").ToModelOutputDefaultFn;
-    readonly MCP: <TOutput>(result: TOutput | Error, tool: import("../index.js").VovkTool, req: Pick<import("../index.js").VovkRequest, "vovk"> | null) => Promise<import("./to-model-output-mcp.js").MCPModelOutput>;
+    readonly MCP: <TOutput>(result: TOutput | Error, tool: import("../internal.js").StandardToolV0<import("../types/utils.js").KnownAny, import("../types/utils.js").KnownAny, import("../types/utils.js").KnownAny>, req: Pick<import("../index.js").VovkRequest, "vovk"> | null) => Promise<import("./to-model-output-mcp.js").MCPModelOutput>;
 };

package/dist/types/client.d.ts

@@ -1,11 +1,11 @@
 import type { NextResponse } from 'next/server.js';
-import type { JSONLinesResponder } from '../core/json-lines-responder.js';
-import type { defaultStreamHandler } from '../client/default-stream-handler.js';
 import type { defaultHandler } from '../client/default-handler.js';
-import type { VovkRequest } from './request.js';
+import type { defaultStreamHandler } from '../client/default-stream-handler.js';
+import type { JSONLinesResponder } from '../core/json-lines-responder.js';
 import type { ControllerStaticMethod, VovkControllerSchema, VovkHandlerSchema, VovkSchema, VovkSegmentSchema } from './core.js';
-import type { IsEmptyObject, KnownAny, Prettify } from './utils.js';
 import type { HttpMethod } from './enums.js';
+import type { VovkRequest } from './request.js';
+import type { IsEmptyObject, KnownAny, Prettify } from './utils.js';
 import type { BodyTypeFromContentType, ContentType, VovkValidateOnClient } from './validation.js';
 type OmitNullable<T> = {
     [K in keyof T as T[K] extends null | undefined ? never : K]: T[K];

package/dist/types/config.d.ts

@@ -1,7 +1,7 @@
 import type { OpenAPIObject } from 'openapi3-ts/oas31';
-import type { PackageJson } from './package.js';
 import type { HttpMethod, VovkSchemaIdEnum } from './enums.js';
 import type { VovkOperationObject } from './operation.js';
+import type { PackageJson } from './package.js';
 import type { KnownAny, RequireFields } from './utils.js';
 export type VovkPackageJson = PackageJson & {
     rs_name?: string;
@@ -86,17 +86,16 @@ export interface VovkOpenAPIMixin {
         object: OpenAPIObject;
     };
     apiRoot?: string;
-    getModuleName?: 'nestjs-operation-id' | (string & {}) | 'api' | GetOpenAPINameFn;
-    getMethodName?: 'nestjs-operation-id' | 'camel-case-operation-id' | 'auto' | GetOpenAPINameFn;
+    getModuleName?: (string & {}) | 'api' | GetOpenAPINameFn;
+    getMethodName?: 'camel-case-operation-id' | 'auto' | GetOpenAPINameFn;
     /**
      * Keep only operations the predicate returns `true` for; omitted = keep all. Runs before
      * `getModuleName`/`getMethodName`, so a module whose operations are all filtered out is never created.
      */
     filterOperations?: (config: Parameters<GetOpenAPINameFn>[0]) => boolean;
     /**
-     * Prune `meta.openAPIObject.components.schemas` to the transitive `$ref` closure of the kept operations,
-     * shrinking the generated schema for large specs. Removes `Mixins.<Segment>.<Component>` types for
-     * components nothing kept references — keep `false` (default) if you import such types directly.
+     * Prune `meta.openAPIObject.components.schemas` to the `$ref` closure of kept operations (shrinks big
+     * specs); removes unreferenced `Mixins.*` types, keep `false` (default) if you import those directly.
      */
     pruneComponents?: boolean;
     errorMessageKey?: string;

package/dist/types/core.d.ts

@@ -1,11 +1,11 @@
 import type { OpenAPIObject } from 'openapi3-ts/oas31';
+import type { Responder } from '../core/json-lines-responder.js';
 import type { VovkPackageJson, VovkStrictConfig } from './config.js';
 import type { HttpStatus, VovkSchemaIdEnum } from './enums.js';
 import type { VovkJSONSchemaBase } from './json-schema.js';
 import type { VovkOperationObject } from './operation.js';
 import type { VovkRequest } from './request.js';
 import type { KnownAny, RequireFields, StaticClass } from './utils.js';
-import type { Responder } from '../core/json-lines-responder.js';
 /**
  * Schema for an individual handler, available as MyRPC.myHandler.schema and MyController.myHandler.schema
  */
@@ -106,6 +106,9 @@ export type DecoratorOptions = {
 };
 export type RouteHandler = ((req: VovkRequest, params: Record<string, string>) => Response | Promise<Response> | Responder | Promise<Responder> | Iterable<unknown> | AsyncIterable<unknown>) & {
     _options?: DecoratorOptions;
+    _sourceMethod?: {
+        wrapper?: RouteHandler;
+    };
 };
 export type ControllerStaticMethod<REQ extends VovkRequest = VovkRequest, TParams extends {
     [key: string]: string;

package/dist/types/enums.d.ts

@@ -56,7 +56,7 @@ export declare enum HttpStatus {
     UNPROCESSABLE_ENTITY = 422,
     FAILED_DEPENDENCY = 424,
     PRECONDITION_REQUIRED = 428,
-    TOO_MANY_TRequestS = 429,
+    TOO_MANY_REQUESTS = 429,
     INTERNAL_SERVER_ERROR = 500,
     NOT_IMPLEMENTED = 501,
     BAD_GATEWAY = 502,

package/dist/types/enums.js

@@ -58,7 +58,7 @@ export var HttpStatus;
     HttpStatus[HttpStatus["UNPROCESSABLE_ENTITY"] = 422] = "UNPROCESSABLE_ENTITY";
     HttpStatus[HttpStatus["FAILED_DEPENDENCY"] = 424] = "FAILED_DEPENDENCY";
     HttpStatus[HttpStatus["PRECONDITION_REQUIRED"] = 428] = "PRECONDITION_REQUIRED";
-    HttpStatus[HttpStatus["TOO_MANY_TRequestS"] = 429] = "TOO_MANY_TRequestS";
+    HttpStatus[HttpStatus["TOO_MANY_REQUESTS"] = 429] = "TOO_MANY_REQUESTS";
     HttpStatus[HttpStatus["INTERNAL_SERVER_ERROR"] = 500] = "INTERNAL_SERVER_ERROR";
     HttpStatus[HttpStatus["NOT_IMPLEMENTED"] = 501] = "NOT_IMPLEMENTED";
     HttpStatus[HttpStatus["BAD_GATEWAY"] = 502] = "BAD_GATEWAY";

package/dist/types/inference.d.ts

@@ -113,9 +113,8 @@ type _OmitUndefinedOrUnknown<T> = {
     [K in keyof T as unknown extends T[K] ? never : [T[K]] extends [undefined] ? never : K]: T[K];
 };
 /**
- * Utility type to extract the full input (params, query, body) from both controller and client methods.
- * Only includes properties that are actually defined — omits keys whose types resolve to `undefined` or `unknown`.
- * Useful for Next.js server actions and other cases where you need all input types at once.
+ * Extracts the full input (params, query, body) from both controller and client methods,
+ * omitting keys that resolve to `undefined` or `unknown`.
  * @see https://vovk.dev/inference
  * @example
  * ```ts

package/dist/types/request.d.ts

@@ -8,11 +8,7 @@ export type VovkRequestCookie = {
     [key: string]: string;
 };
 /**
- * The Vovk.ts request object, extending Next.js's NextRequest
- * Accepts three generic parameters:
- * - TBody: the expected shape of the request body (default: unknown)
- * - TQuery: the expected shape of the query parameters (default: unknown)
- * - TParams: the expected shape of the route parameters (default: unknown)
+ * The Vovk.ts request object extending Next.js's NextRequest, generics: TBody, TQuery, TParams.
  * @see https://vovk.dev/procedure
  */
 export interface VovkRequest<TBody = unknown, TQuery = unknown, TParams = unknown> extends Request {

package/dist/types/standard-schema.js

@@ -1,5 +1,3 @@
-/* eslint-disable @typescript-eslint/no-empty-object-type */
-/* eslint-disable @typescript-eslint/no-namespace */
 // #########################
 // ###   Standard Typed  ###
 // #########################

package/dist/types/standard-tool.d.ts

@@ -1,17 +1,13 @@
-import type { CombinedSpec } from './validation.js';
-import type { KnownAny } from './utils.js';
+import type { StandardJSONSchemaV1, StandardSchemaV1 } from './standard-schema.js';
 /**
- * The `standard-tool` convention (https://github.com/finom/standard-tool): a neutral LLM tool shape —
- * `name`, `description`, optional `inputSchema`/`outputSchema`, `execute`. Vendored as a type only
- * (no logic) so `VovkTool` can extend it with zero added dependencies. Kept identical to the
- * `StandardTool` type published by `standard-tool` (`meta` is `KnownAny`, i.e. its `any`).
+ * Vendored `standard-tool` type (https://standard-tool.js.org), no dependency, no logic.
+ * Keep it identical to the published `StandardToolV0` interface.
  */
-export interface StandardTool<Input = unknown, Output = unknown, FormattedOutput = Output | {
-    error: string;
-}> {
+export interface StandardToolV0<Input = unknown, Output = unknown, FormattedOutput = Output, Meta = unknown> {
     name: string;
+    title?: string;
     description: string;
-    inputSchema?: CombinedSpec<Input>;
-    outputSchema?: CombinedSpec<Output>;
-    execute(input: Input, meta?: KnownAny): FormattedOutput | Promise<FormattedOutput>;
+    inputSchema?: StandardSchemaV1<Input> & StandardJSONSchemaV1<Input>;
+    outputSchema?: StandardSchemaV1<Output> & StandardJSONSchemaV1<Output>;
+    execute(input: Input, meta?: Meta): FormattedOutput | Promise<FormattedOutput>;
 }

package/dist/types/tools.d.ts

@@ -1,44 +1,6 @@
-import type { VovkJSONSchemaBase } from './json-schema.js';
 import type { VovkRequest } from './request.js';
-import type { CombinedSpec } from './validation.js';
-import type { StandardTool } from './standard-tool.js';
-import type { KnownAny } from './utils.js';
-export type ToModelOutputFn<TInput, TOutput, TFormattedOutput> = (result: TOutput | Error, tool: VovkTool<TInput, TOutput, unknown>, req: Pick<VovkRequest, 'vovk'> | null) => TFormattedOutput | Promise<TFormattedOutput>;
-/**
- * Vovk tool — produced by both `deriveTools` (procedures → tools) and
- * `createTool` (standalone tools); both return the same shape. Extends the
- * {@link StandardTool} convention with Vovk specifics (`title`, `parameters`, `type`).
- * @see https://vovk.dev/tools
- */
-export interface VovkTool<TInput = KnownAny, TOutput = KnownAny, TFormattedOutput = KnownAny> extends StandardTool<TInput, TOutput, TFormattedOutput> {
-    title: string | undefined;
-    parameters: {
-        type?: 'object';
-        properties?: {
-            body?: VovkJSONSchemaBase;
-            query?: VovkJSONSchemaBase;
-            params?: VovkJSONSchemaBase;
-        };
-        required?: ('body' | 'query' | 'params')[];
-        additionalProperties?: false;
-    };
-    inputSchema: TInput extends undefined ? undefined : CombinedSpec<TInput>;
-    outputSchema: TOutput extends undefined ? undefined : CombinedSpec<TOutput>;
-    /**
-     * Per-slot Standard Schemas, populated only when the tool was built via
-     * `deriveTools` from a procedure. Always `undefined` for tools built via
-     * `createTool`.
-     *
-     * @deprecated Use {@link VovkTool.inputSchema} (a merged Standard Schema)
-     * instead. This field will be removed in the next major version.
-     */
-    inputSchemas?: {
-        body?: CombinedSpec;
-        query?: CombinedSpec;
-        params?: CombinedSpec;
-    };
-    type: 'function';
-}
+import type { StandardToolV0 } from './standard-tool.js';
+export type ToModelOutputFn<TInput, TOutput, TFormattedOutput> = (result: TOutput | Error, tool: StandardToolV0<TInput, TOutput, unknown>, req: Pick<VovkRequest, 'vovk'> | null) => TFormattedOutput | Promise<TFormattedOutput>;
 export type VovkToolOptions = {
     hidden?: boolean;
     name?: string;

package/dist/types/validation.d.ts

@@ -1,7 +1,7 @@
-import type { StandardSchemaV1, StandardJSONSchemaV1 } from './standard-schema.js';
-import type { KnownAny } from './utils.js';
-import type { VovkHandlerSchema, VovkSchema } from './core.js';
 import type { textTypes } from '../req/parse-body.js';
+import type { VovkHandlerSchema, VovkSchema } from './core.js';
+import type { StandardJSONSchemaV1, StandardSchemaV1 } from './standard-schema.js';
+import type { KnownAny } from './utils.js';
 export interface CombinedProps<Input = unknown, Output = Input> extends StandardSchemaV1.Props<Input, Output>, StandardJSONSchemaV1.Props<Input, Output> {
 }
 /**

package/dist/utils/camel-case.d.ts

@@ -1,6 +1 @@
-/**
- * Converts string to camel case.
- * @param {*} input - The value to convert to camel case.
- * @returns {string}
- */
 export declare function camelCase(input: string): string;

package/dist/utils/camel-case.js

@@ -4,19 +4,11 @@ function valToString(value) {
 }
 // Regex to match words (including Unicode letters & digits)
 const reUnicodeWord = /[\p{Lu}]{2,}(?=[\p{Lu}][\p{Ll}]+[0-9]*|\b)|[\p{Lu}]?[\p{Ll}]+[0-9]*|[\p{Lu}]|[0-9]+/gu;
-/**
- * Splits string into an array of words based on Unicode word boundaries
- * @param {string} str
- * @returns {string[]}
- */
+// splits string into words based on Unicode word boundaries
 function unicodeWords(str) {
     return str.match(reUnicodeWord) || [];
 }
-/**
- * Converts string to camel case.
- * @param {*} input - The value to convert to camel case.
- * @returns {string}
- */
+// converts string to camel case
 export function camelCase(input) {
     const str = valToString(input);
     // replace separators with space

package/dist/utils/deep-extend.d.ts

@@ -36,19 +36,10 @@ declare function cloneSpecificValue(val: SpecificValue): SpecificValue;
  */
 declare function deepCloneArray<T = KnownAny>(arr: T[]): T[];
 declare function safeGetProperty<T extends object>(object: T, property: PropertyKey): KnownAny;
-/**
- * Extending object that entered in first argument.
- *
- * Returns extended object or false if have no target object or incorrect type.
- *
- * If you wish to clone source object (without modify it), just use empty new
- * object as first argument, like this:
- *   deepExtend({}, yourObj_1, [yourObj_N]);
- */
 declare function deepExtend<T extends object>(...args: [T, ...Partial<T>[]]): T;
 declare function deepExtend<T extends object, U extends object>(target: T, source: U): T & U;
 declare function deepExtend<T extends object, U extends object, V extends object>(target: T, source1: U, source2: V): T & U & V;
 declare function deepExtend<T extends object, U extends object, V extends object, W extends object>(target: T, source1: U, source2: V, source3: W): T & U & V & W;
 declare function deepExtend<T extends object>(target: T, ...sources: KnownAny[]): T;
-export { deepExtend, deepCloneArray, isSpecificValue, cloneSpecificValue, safeGetProperty };
 export type { DeepPartial, SpecificValue };
+export { cloneSpecificValue, deepCloneArray, deepExtend, isSpecificValue, safeGetProperty };

package/dist/utils/deep-extend.js

@@ -1,4 +1,3 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
 /*!
  * @description Recursive object extending
  * @author Viacheslav Lotsmanov <lotsmanov89@gmail.com>
@@ -28,6 +27,11 @@
 function isSpecificValue(val) {
     return val instanceof Buffer || val instanceof Date || val instanceof RegExp;
 }
+// class instances like Headers or AbortSignal have no enumerable keys and must not be fake-cloned into {}
+function isPlainObject(val) {
+    const proto = Object.getPrototypeOf(val);
+    return proto === Object.prototype || proto === null;
+}
 function cloneSpecificValue(val) {
     if (val instanceof Buffer) {
         const x = Buffer.alloc ? Buffer.alloc(val.length) : Buffer.from(val);
@@ -57,6 +61,9 @@ function deepCloneArray(arr) {
             else if (isSpecificValue(item)) {
                 clone[index] = cloneSpecificValue(item);
             }
+            else if (!isPlainObject(item)) {
+                clone[index] = item;
+            }
             else {
                 clone[index] = deepExtend({}, item);
             }
@@ -110,8 +117,13 @@ function deepExtend(...args) {
                 target[key] = cloneSpecificValue(val);
                 return;
             }
-            // overwrite by new value if source isn't object or array
-            else if (typeof src !== 'object' || src === null || Array.isArray(src)) {
+            // pass class instances by reference, cloning by enumerable keys would produce {}
+            else if (!isPlainObject(val)) {
+                target[key] = val;
+                return;
+            }
+            // overwrite by new value if source isn't a plain object or is an array
+            else if (typeof src !== 'object' || src === null || Array.isArray(src) || !isPlainObject(src)) {
                 target[key] = deepExtend({}, val);
                 return;
             }
@@ -124,4 +136,4 @@ function deepExtend(...args) {
     });
     return target;
 }
-export { deepExtend, deepCloneArray, isSpecificValue, cloneSpecificValue, safeGetProperty };
+export { cloneSpecificValue, deepCloneArray, deepExtend, isSpecificValue, safeGetProperty };