recker 1.0.72 → 1.0.75-next.2e5a94f

package/dist/transport/fetch.js

@@ -1,4 +1,5 @@
 import { createProgressStream } from '../utils/progress.js';
+import { TimeoutError } from '../core/errors.js';
 function parseContentLength(headers) {
     const raw = headers.get('content-length');
     if (!raw)
@@ -6,6 +7,19 @@ function parseContentLength(headers) {
     const parsed = parseInt(raw, 10);
     return Number.isFinite(parsed) ? parsed : undefined;
 }
+function getAbortReason(error) {
+    return error?.cause ?? error?.reason;
+}
+function isTimeoutReason(reason) {
+    if (reason instanceof TimeoutError) {
+        return true;
+    }
+    if (!reason || typeof reason !== 'object') {
+        return false;
+    }
+    const timeoutReason = reason;
+    return timeoutReason.name === 'TimeoutError';
+}
 function wrapDownloadResponse(response, onProgress) {
     if (!onProgress || !response.body)
         return response;
@@ -66,10 +80,16 @@ export class FetchTransport {
             ? req.timeout
             : req.timeout?.request;
         let signal = req.signal;
+        const requestTimeoutError = timeoutMs ? new TimeoutError(req, {
+            phase: 'request',
+            timeout: timeoutMs
+        }) : undefined;
         if (timeoutMs && !signal) {
             abortController = new AbortController();
             signal = abortController.signal;
-            timeoutId = setTimeout(() => abortController.abort(), timeoutMs);
+            timeoutId = setTimeout(() => {
+                timeoutControllerAbort(abortController, requestTimeoutError);
+            }, timeoutMs);
         }
         const followRedirects = req.followRedirects !== false;
         const maxRedirects = req.maxRedirects ?? 20;
@@ -148,10 +168,13 @@ export class FetchTransport {
             }
         }
         catch (error) {
-            if (error.name === 'AbortError' && abortController) {
-                const timeoutError = new Error(`Request timeout after ${timeoutMs}ms`);
-                timeoutError.name = 'TimeoutError';
-                throw timeoutError;
+            if (timeoutMs && (error.name === 'AbortError' || error.name === 'TimeoutError')) {
+                const timeoutReason = getAbortReason(error);
+                if (isTimeoutReason(timeoutReason) ||
+                    isTimeoutReason(getAbortReason(signal)) ||
+                    (abortController && isTimeoutReason(requestTimeoutError))) {
+                    throw timeoutReason instanceof TimeoutError ? timeoutReason : requestTimeoutError ?? error;
+                }
             }
             throw error;
         }
@@ -161,6 +184,16 @@ export class FetchTransport {
         }
     }
 }
+function timeoutControllerAbort(controller, reason) {
+    if (!controller.signal.aborted) {
+        if (reason) {
+            controller.abort(reason);
+        }
+        else {
+            controller.abort();
+        }
+    }
+}
 class FetchResponseWrapper {
     raw;
     timings;

package/dist/transport/undici.js

@@ -15,6 +15,40 @@ const undiciBodySentChannel = channel('undici:request:bodySent');
 const undiciHeadersChannel = channel('undici:request:headers');
 const undiciConnectChannel = channel('undici:client:connect');
 const requestStorage = new AsyncLocalStorage();
+function getAbortReason(error) {
+    return error?.cause ?? error?.reason;
+}
+function isTimeoutAbortReason(reason) {
+    if (reason instanceof TimeoutError) {
+        return true;
+    }
+    if (!reason || typeof reason !== 'object') {
+        return false;
+    }
+    const timeoutReason = reason;
+    return timeoutReason.name === 'TimeoutError';
+}
+function isTotalRequestTimeoutError(error, timeoutReason, timeoutMs) {
+    if (!timeoutMs) {
+        return false;
+    }
+    if (timeoutReason !== undefined) {
+        return true;
+    }
+    const causeOrReason = getAbortReason(error);
+    const message = error?.message;
+    const hasTimeoutMessage = typeof message === 'string' && (message.includes('Request timed out (total time exceeded)') ||
+        message.includes('timed out (total time exceeded)'));
+    const hasRequestAbortMessage = typeof message === 'string' && message.toLowerCase() === 'request was aborted';
+    return (error instanceof TimeoutError ||
+        isTimeoutAbortReason(causeOrReason) ||
+        isTimeoutAbortReason(error) ||
+        error instanceof undiciErrors.RequestAbortedError ||
+        hasTimeoutMessage ||
+        hasRequestAbortMessage ||
+        error?.code === 'ABORT_ERR' ||
+        error?.code === 'UND_ERR_REQUEST_TIMEOUT');
+}
 undiciRequestChannel.subscribe((message) => {
     const store = requestStorage.getStore();
     if (store) {
@@ -36,7 +70,7 @@ undiciRequestChannel.subscribe((message) => {
         }
     }
 });
-undiciBodySentChannel.subscribe((message) => {
+undiciBodySentChannel.subscribe((_message) => {
     const store = requestStorage.getStore();
     if (store?.hooks && store.hooks.onRequestSent) {
         store.hooks.onRequestSent();
@@ -317,6 +351,9 @@ export class UndiciTransport {
         });
         let timeoutController;
         let timeoutId;
+        let timeoutReason;
+        let timeoutError;
+        let cancelOriginalAbortListener;
         if (!this.observability) {
             return this.dispatchFast(req, headers, currentUrl, timeouts, handleRedirectsManually, maxRedirects, followRedirects, uploadTotal);
         }
@@ -340,24 +377,32 @@ export class UndiciTransport {
                 let effectiveSignal = req.signal;
                 if (timeouts.totalTimeout) {
                     timeoutController = new AbortController();
+                    timeoutError = new TimeoutError(req, {
+                        phase: 'request',
+                        timeout: timeouts.totalTimeout
+                    });
                     if (req.signal) {
                         const originalSignal = req.signal;
                         effectiveSignal = timeoutController.signal;
                         const onOriginalAbort = () => {
-                            timeoutController.abort();
+                            timeoutReason = originalSignal.reason ?? new Error('Request aborted by external signal');
+                            timeoutController.abort(timeoutReason);
                         };
                         if (originalSignal.aborted) {
-                            timeoutController.abort();
+                            timeoutReason = originalSignal.reason ?? new Error('Request aborted by external signal');
+                            timeoutController.abort(timeoutReason);
                         }
                         else {
                             originalSignal.addEventListener('abort', onOriginalAbort, { once: true });
+                            cancelOriginalAbortListener = () => originalSignal.removeEventListener('abort', onOriginalAbort);
                         }
                     }
                     else {
                         effectiveSignal = timeoutController.signal;
                     }
                     timeoutId = setTimeout(() => {
-                        timeoutController.abort();
+                        timeoutReason = timeoutError;
+                        timeoutController.abort(timeoutReason);
                     }, timeouts.totalTimeout);
                 }
                 while (true) {
@@ -593,8 +638,8 @@ export class UndiciTransport {
                         timeout: timeouts.bodyTimeout
                     });
                 }
-                if (error.name === 'AbortError' || error.code === 'ABORT_ERR') {
-                    throw new TimeoutError(req, {
+                if (isTotalRequestTimeoutError(error, timeoutReason, timeouts.totalTimeout)) {
+                    throw timeoutError ?? new TimeoutError(req, {
                         phase: 'request',
                         timeout: timeouts.totalTimeout
                     });
@@ -611,6 +656,9 @@ export class UndiciTransport {
                 throw new NetworkError(error.message, code, req);
             }
             finally {
+                if (typeof cancelOriginalAbortListener === 'function') {
+                    cancelOriginalAbortListener();
+                }
                 if (timeoutId) {
                     clearTimeout(timeoutId);
                 }
@@ -620,6 +668,9 @@ export class UndiciTransport {
     async dispatchFast(req, headers, currentUrl, timeouts, handleRedirectsManually, maxRedirects, followRedirects, uploadTotal) {
         let timeoutController;
         let timeoutId;
+        let timeoutReason;
+        let timeoutError;
+        let cancelOriginalAbortListener;
         try {
             let redirectCount = 0;
             let currentMethod = req.method;
@@ -628,24 +679,32 @@ export class UndiciTransport {
             let effectiveSignal = req.signal;
             if (timeouts.totalTimeout) {
                 timeoutController = new AbortController();
+                timeoutError = new TimeoutError(req, {
+                    phase: 'request',
+                    timeout: timeouts.totalTimeout
+                });
                 if (req.signal) {
                     const originalSignal = req.signal;
                     effectiveSignal = timeoutController.signal;
                     const onOriginalAbort = () => {
-                        timeoutController.abort();
+                        timeoutReason = originalSignal.reason ?? new Error('Request aborted by external signal');
+                        timeoutController.abort(timeoutReason);
                     };
                     if (originalSignal.aborted) {
-                        timeoutController.abort();
+                        timeoutReason = originalSignal.reason ?? new Error('Request aborted by external signal');
+                        timeoutController.abort(timeoutReason);
                     }
                     else {
                         originalSignal.addEventListener('abort', onOriginalAbort, { once: true });
+                        cancelOriginalAbortListener = () => originalSignal.removeEventListener('abort', onOriginalAbort);
                     }
                 }
                 else {
                     effectiveSignal = timeoutController.signal;
                 }
                 timeoutId = setTimeout(() => {
-                    timeoutController.abort();
+                    timeoutReason = timeoutError;
+                    timeoutController.abort(timeoutReason);
                 }, timeouts.totalTimeout);
             }
             while (true) {
@@ -822,8 +881,8 @@ export class UndiciTransport {
                     timeout: timeouts.bodyTimeout
                 });
             }
-            if (error.name === 'AbortError' || error.code === 'ABORT_ERR') {
-                throw new TimeoutError(req, {
+            if (isTotalRequestTimeoutError(error, timeoutReason, timeouts.totalTimeout)) {
+                throw timeoutError ?? new TimeoutError(req, {
                     phase: 'request',
                     timeout: timeouts.totalTimeout
                 });
@@ -840,6 +899,9 @@ export class UndiciTransport {
             throw new NetworkError(error.message, code, req);
         }
         finally {
+            if (typeof cancelOriginalAbortListener === 'function') {
+                cancelOriginalAbortListener();
+            }
             if (timeoutId) {
                 clearTimeout(timeoutId);
             }

package/dist/transport/worker.d.ts

@@ -3,7 +3,6 @@ export interface WorkerTransportOptions {
     poolSize?: number;
 }
 export declare class WorkerTransport implements Transport {
-    private options;
     private workers;
     private workerIndex;
     private pendingRequests;

package/dist/transport/worker.js

@@ -58,13 +58,11 @@ self.onmessage = async (event) => {
 };
 `;
 export class WorkerTransport {
-    options;
     workers = [];
     workerIndex = 0;
     pendingRequests = new Map();
     workerUrl;
     constructor(options = {}) {
-        this.options = options;
         const poolSize = options.poolSize ?? (typeof navigator !== 'undefined' ? navigator.hardwareConcurrency : 4) ?? 4;
         const blob = new Blob([WORKER_SCRIPT], { type: 'application/javascript' });
         this.workerUrl = URL.createObjectURL(blob);
@@ -166,7 +164,7 @@ export class WorkerTransport {
         }
         this.workers = [];
         URL.revokeObjectURL(this.workerUrl);
-        for (const [id, pending] of this.pendingRequests) {
+        for (const pending of this.pendingRequests.values()) {
             pending.reject(new Error('Transport terminated'));
         }
         this.pendingRequests.clear();

package/dist/types/index.d.ts

@@ -24,6 +24,10 @@ export interface RedirectInfo {
     status: number;
     headers: Headers;
 }
+export interface ReckerRuntimeEventBus {
+    on<K extends string>(name: K, handler: (event: unknown) => void): () => void;
+    emit<K extends string>(name: K, event: unknown): void;
+}
 export interface RequestOptions {
     method?: Method;
     headers?: HeadersInit;
@@ -40,6 +44,11 @@ export interface RequestOptions {
     onUploadProgress?: ProgressCallback;
     onDownloadProgress?: ProgressCallback;
     maxResponseSize?: number;
+    correlationId?: string;
+    tenant?: string;
+    policyTags?: string[];
+    policySource?: string;
+    traceId?: string;
     beforeRedirect?: (info: RedirectInfo) => void | false | string | Promise<void | false | string>;
     maxRedirects?: number;
     followRedirects?: boolean;
@@ -57,6 +66,11 @@ export interface ReckerRequest {
     onUploadProgress?: ProgressCallback;
     onDownloadProgress?: ProgressCallback;
     maxResponseSize?: number;
+    correlationId?: string;
+    tenant?: string;
+    policyTags?: string[];
+    policySource?: string;
+    traceId?: string;
     beforeRedirect?: (info: RedirectInfo) => void | false | string | Promise<void | false | string>;
     maxRedirects?: number;
     followRedirects?: boolean;
@@ -74,6 +88,15 @@ export interface ReckerRequest {
         onHttp2Stream?: (info: any) => void;
         onHttp2FlowControl?: (info: any) => void;
     };
+    _runtime?: {
+        requestId: string;
+        correlationId: string;
+        tenant?: string;
+        policyTags: string[];
+        policySource?: string;
+        createdAt: number;
+        traceId?: string;
+    };
 }
 export interface Timings {
     queuing?: number;
@@ -378,6 +401,7 @@ export interface ClientOptions {
     cookies?: boolean | CookieOptions;
     timeout?: number | TimeoutOptions;
     observability?: boolean;
+    runtimeEventBus?: ReckerRuntimeEventBus;
     retry?: {
         maxAttempts?: number;
         delay?: number;

package/dist/version.js

@@ -1,4 +1,4 @@
-const VERSION = '1.0.72';
+const VERSION = '1.0.75-next.2e5a94f';
 let _version = null;
 export async function getVersion() {
     if (_version)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "recker",
-  "version": "1.0.72",
+  "version": "1.0.75-next.2e5a94f",
   "description": "Multi-Protocol SDK for the AI Era - HTTP, WebSocket, DNS, FTP, SFTP, Telnet, HLS unified with AI providers and MCP tools",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -127,6 +127,14 @@
       "types": "./dist/plugins/*.d.ts",
       "import": "./dist/plugins/*.js"
     },
+    "./search": {
+      "types": "./dist/search/index.d.ts",
+      "import": "./dist/search/index.js"
+    },
+    "./search/*": {
+      "types": "./dist/search/*.d.ts",
+      "import": "./dist/search/*.js"
+    },
     "./scrape": {
       "types": "./dist/scrape/index.d.ts",
       "import": "./dist/scrape/index.js"