@private.me/xbind 3.0.2 → 3.0.4

package/dist-standalone/health-check.js

@@ -1,332 +1 @@
-/**
- * @module health-check
- * Health check endpoint for operational monitoring and load balancer probes.
- *
- * Provides three probe types following Kubernetes health check patterns:
- * - **Startup probe**: Verify initialization complete (one-time check)
- * - **Readiness probe**: Verify dependencies ready (registry, transport)
- * - **Liveness probe**: Verify service responsive (self-check)
- *
- * @example
- * ```typescript
- * import { createHealthChecker } from '@private.me/xbind';
- *
- * const checker = createHealthChecker({
- *   registry: myTrustRegistry,
- *   transport: myTransport
- * });
- *
- * // Load balancer endpoint
- * app.get('/health', async (req, res) => {
- *   const status = await checker.check();
- *   res.status(status.healthy ? 200 : 503).json(status);
- * });
- * ```
- */
-/* ── Implementation ── */
-class HealthCheckerImpl {
-    startTime;
-    registry;
-    transport;
-    serviceName;
-    version;
-    environment;
-    timeoutMs;
-    enableStartupProbe;
-    startupComplete = false;
-    constructor(options = {}) {
-        this.startTime = Date.now();
-        this.registry = options.registry;
-        this.transport = options.transport;
-        this.serviceName = options.serviceName;
-        this.version = options.version;
-        this.environment = options.environment;
-        this.timeoutMs = options.timeoutMs ?? 5000;
-        this.enableStartupProbe = options.enableStartupProbe ?? true;
-    }
-    markStartupComplete() {
-        this.startupComplete = true;
-    }
-    isStartupComplete() {
-        return this.startupComplete;
-    }
-    async check(probe = 'readiness') {
-        const timestamp = new Date().toISOString();
-        const uptimeSeconds = Math.floor((Date.now() - this.startTime) / 1000);
-        // Startup probe: Check if initialization complete
-        if (probe === 'startup' && this.enableStartupProbe) {
-            const components = [
-                {
-                    name: 'startup',
-                    status: this.startupComplete ? 'healthy' : 'unhealthy',
-                    message: this.startupComplete
-                        ? 'Initialization complete'
-                        : 'Waiting for startup completion (call markStartupComplete())',
-                    lastCheck: timestamp,
-                },
-            ];
-            return {
-                healthy: this.startupComplete,
-                timestamp,
-                uptimeSeconds,
-                components,
-                metadata: this.buildMetadata(),
-            };
-        }
-        // Liveness probe: Basic self-check (service responsive)
-        if (probe === 'liveness') {
-            const components = [
-                {
-                    name: 'self',
-                    status: 'healthy',
-                    message: 'Service responsive',
-                    lastCheck: timestamp,
-                },
-            ];
-            return {
-                healthy: true,
-                timestamp,
-                uptimeSeconds,
-                components,
-                metadata: this.buildMetadata(),
-            };
-        }
-        // Readiness probe: Check all dependencies
-        const components = [];
-        // Check registry if configured
-        if (this.registry) {
-            const registryHealth = await this.checkRegistry();
-            components.push(registryHealth);
-        }
-        // Check transport if configured
-        if (this.transport) {
-            const transportHealth = await this.checkTransport();
-            components.push(transportHealth);
-        }
-        // If no components configured, return basic health
-        if (components.length === 0) {
-            components.push({
-                name: 'self',
-                status: 'healthy',
-                message: 'No dependencies configured',
-                lastCheck: timestamp,
-            });
-        }
-        // Overall health: healthy if all components healthy
-        const healthy = components.every((c) => c.status === 'healthy');
-        return {
-            healthy,
-            timestamp,
-            uptimeSeconds,
-            components,
-            metadata: this.buildMetadata(),
-        };
-    }
-    buildMetadata() {
-        const metadata = {};
-        if (this.serviceName)
-            metadata.service = this.serviceName;
-        if (this.version)
-            metadata.version = this.version;
-        if (this.environment)
-            metadata.environment = this.environment;
-        return Object.keys(metadata).length > 0 ? metadata : undefined;
-    }
-    async checkRegistry() {
-        const startTime = Date.now();
-        const lastCheck = new Date().toISOString();
-        try {
-            if (!this.registry) {
-                return {
-                    name: 'registry',
-                    status: 'unhealthy',
-                    message: 'Registry not configured',
-                    lastCheck,
-                };
-            }
-            // Use timeout wrapper
-            const result = await this.withTimeout(this.registry.resolve('did:xail:health_check_probe'), this.timeoutMs);
-            const latencyMs = Date.now() - startTime;
-            // Registry returns Result<Uint8Array, RegistryError>
-            // For non-existent DIDs, it returns err with NOT_FOUND code (this is healthy behavior)
-            // For registry errors, it returns err with other error codes (unhealthy)
-            if (result && typeof result === 'object' && 'ok' in result) {
-                // Result type - check if ok or err
-                if (result.ok) {
-                    // Registry found the DID (healthy)
-                    return {
-                        name: 'registry',
-                        status: 'healthy',
-                        message: 'Registry responding',
-                        latencyMs,
-                        lastCheck,
-                    };
-                }
-                else {
-                    // Registry returned an error
-                    const errorCode = typeof result.error === 'string' ? result.error : 'UNKNOWN';
-                    // NOT_FOUND is healthy (registry works, DID doesn't exist)
-                    if (errorCode.includes('NOT_FOUND')) {
-                        return {
-                            name: 'registry',
-                            status: 'healthy',
-                            message: 'Registry responding',
-                            latencyMs,
-                            lastCheck,
-                        };
-                    }
-                    // Other errors are unhealthy
-                    return {
-                        name: 'registry',
-                        status: 'unhealthy',
-                        message: `Registry error: ${errorCode}`,
-                        latencyMs,
-                        lastCheck,
-                    };
-                }
-            }
-            // Fallback: if result is anything else, assume healthy
-            return {
-                name: 'registry',
-                status: 'healthy',
-                message: 'Registry responding',
-                latencyMs,
-                lastCheck,
-            };
-        }
-        catch (error) {
-            const latencyMs = Date.now() - startTime;
-            const message = error instanceof Error ? error.message : 'Unknown error';
-            // Timeout is degraded (slow but responsive)
-            if (message.toLowerCase().includes('timeout')) {
-                return {
-                    name: 'registry',
-                    status: 'degraded',
-                    message: `Registry slow (>${this.timeoutMs}ms)`,
-                    latencyMs,
-                    lastCheck,
-                };
-            }
-            // Other errors are unhealthy
-            return {
-                name: 'registry',
-                status: 'unhealthy',
-                message: `Registry error: ${message}`,
-                latencyMs,
-                lastCheck,
-            };
-        }
-    }
-    async checkTransport() {
-        const startTime = Date.now();
-        const lastCheck = new Date().toISOString();
-        try {
-            if (!this.transport) {
-                return {
-                    name: 'transport',
-                    status: 'unhealthy',
-                    message: 'Transport not configured',
-                    lastCheck,
-                };
-            }
-            // Transport doesn't expose a health check method, so we check if it's instantiated
-            // In production, you might want to add a ping() method to XailTransportAdapter
-            const latencyMs = Date.now() - startTime;
-            return {
-                name: 'transport',
-                status: 'healthy',
-                message: 'Transport adapter available',
-                latencyMs,
-                lastCheck,
-            };
-        }
-        catch (error) {
-            const latencyMs = Date.now() - startTime;
-            const message = error instanceof Error ? error.message : 'Unknown error';
-            return {
-                name: 'transport',
-                status: 'unhealthy',
-                message: `Transport error: ${message}`,
-                latencyMs,
-                lastCheck,
-            };
-        }
-    }
-    async withTimeout(promise, timeoutMs) {
-        return Promise.race([
-            promise,
-            new Promise((_, reject) => setTimeout(() => reject(new Error('Health check timeout')), timeoutMs)),
-        ]);
-    }
-}
-/* ── Public API ── */
-/**
- * Create a health checker instance.
- *
- * @param options - Configuration options
- * @returns Health checker instance
- *
- * @example
- * ```typescript
- * const checker = createHealthChecker({
- *   registry: agent.registry,
- *   transport: agent.transport,
- *   serviceName: 'my-service',
- *   version: '1.0.0'
- * });
- *
- * // Mark startup complete after initialization
- * await agent.register();
- * checker.markStartupComplete();
- *
- * // Check health
- * const status = await checker.check('readiness');
- * console.log(status.healthy ? 'Ready' : 'Not ready');
- * ```
- */
-export function createHealthChecker(options) {
-    return new HealthCheckerImpl(options);
-}
-/**
- * Express/Fastify middleware helper for health endpoint.
- *
- * @param checker - Health checker instance
- * @param probe - Probe type (default: 'readiness')
- * @returns Request handler
- *
- * @example
- * ```typescript
- * const checker = createHealthChecker({ registry, transport });
- *
- * // Express
- * app.get('/health', healthEndpoint(checker));
- * app.get('/health/startup', healthEndpoint(checker, 'startup'));
- * app.get('/health/liveness', healthEndpoint(checker, 'liveness'));
- * app.get('/health/readiness', healthEndpoint(checker, 'readiness'));
- * ```
- */
-export function healthEndpoint(checker, probe = 'readiness') {
-    return async (_req, res) => {
-        try {
-            const status = await checker.check(probe);
-            const statusCode = status.healthy ? 200 : 503;
-            res.status(statusCode).json(status);
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : 'Unknown error';
-            res.status(503).json({
-                healthy: false,
-                timestamp: new Date().toISOString(),
-                uptimeSeconds: 0,
-                components: [
-                    {
-                        name: 'health-check',
-                        status: 'unhealthy',
-                        message: `Health check failed: ${message}`,
-                        lastCheck: new Date().toISOString(),
-                    },
-                ],
-            });
-        }
-    };
-}
+class HealthCheckerImpl{startTime;registry;transport;serviceName;version;environment;timeoutMs;enableStartupProbe;startupComplete=!1;constructor(t={}){this.startTime=Date.now(),this.registry=t.registry,this.transport=t.transport,this.serviceName=t.serviceName,this.version=t.version,this.environment=t.environment,this.timeoutMs=t.timeoutMs??5e3,this.enableStartupProbe=t.enableStartupProbe??!0}markStartupComplete(){this.startupComplete=!0}isStartupComplete(){return this.startupComplete}async check(t="readiness"){const e=(new Date).toISOString(),s=Math.floor((Date.now()-this.startTime)/1e3);if("startup"===t&&this.enableStartupProbe){const t=[{name:"startup",status:this.startupComplete?"healthy":"unhealthy",message:this.startupComplete?"Initialization complete":"Waiting for startup completion (call markStartupComplete())",lastCheck:e}];return{healthy:this.startupComplete,timestamp:e,uptimeSeconds:s,components:t,metadata:this.buildMetadata()}}if("liveness"===t){return{healthy:!0,timestamp:e,uptimeSeconds:s,components:[{name:"self",status:"healthy",message:"Service responsive",lastCheck:e}],metadata:this.buildMetadata()}}const a=[];if(this.registry){const t=await this.checkRegistry();a.push(t)}if(this.transport){const t=await this.checkTransport();a.push(t)}0===a.length&&a.push({name:"self",status:"healthy",message:"No dependencies configured",lastCheck:e});return{healthy:a.every(t=>"healthy"===t.status),timestamp:e,uptimeSeconds:s,components:a,metadata:this.buildMetadata()}}buildMetadata(){const t={};return this.serviceName&&(t.service=this.serviceName),this.version&&(t.version=this.version),this.environment&&(t.environment=this.environment),Object.keys(t).length>0?t:void 0}async checkRegistry(){const t=Date.now(),e=(new Date).toISOString();try{if(!this.registry)return{name:"registry",status:"unhealthy",message:"Registry not configured",lastCheck:e};const s=await this.withTimeout(this.registry.resolve("did:xail:health_check_probe"),this.timeoutMs),a=Date.now()-t;if(s&&"object"==typeof s&&"ok"in s){if(s.ok)return{name:"registry",status:"healthy",message:"Registry responding",latencyMs:a,lastCheck:e};{const t="string"==typeof s.error?s.error:"UNKNOWN";return t.includes("NOT_FOUND")?{name:"registry",status:"healthy",message:"Registry responding",latencyMs:a,lastCheck:e}:{name:"registry",status:"unhealthy",message:`Registry error: ${t}`,latencyMs:a,lastCheck:e}}}return{name:"registry",status:"healthy",message:"Registry responding",latencyMs:a,lastCheck:e}}catch(s){const a=Date.now()-t,r=s instanceof Error?s.message:"Unknown error";return r.toLowerCase().includes("timeout")?{name:"registry",status:"degraded",message:`Registry slow (>${this.timeoutMs}ms)`,latencyMs:a,lastCheck:e}:{name:"registry",status:"unhealthy",message:`Registry error: ${r}`,latencyMs:a,lastCheck:e}}}async checkTransport(){const t=Date.now(),e=(new Date).toISOString();try{if(!this.transport)return{name:"transport",status:"unhealthy",message:"Transport not configured",lastCheck:e};return{name:"transport",status:"healthy",message:"Transport adapter available",latencyMs:Date.now()-t,lastCheck:e}}catch(s){const a=Date.now()-t;return{name:"transport",status:"unhealthy",message:`Transport error: ${s instanceof Error?s.message:"Unknown error"}`,latencyMs:a,lastCheck:e}}}async withTimeout(t,e){return Promise.race([t,new Promise((t,s)=>setTimeout(()=>s(new Error("Health check timeout")),e))])}}export function createHealthChecker(t){return new HealthCheckerImpl(t)}export function healthEndpoint(t,e="readiness"){return async(s,a)=>{try{const s=await t.check(e),r=s.healthy?200:503;a.status(r).json(s)}catch(t){const e=t instanceof Error?t.message:"Unknown error";a.status(503).json({healthy:!1,timestamp:(new Date).toISOString(),uptimeSeconds:0,components:[{name:"health-check",status:"unhealthy",message:`Health check failed: ${e}`,lastCheck:(new Date).toISOString()}]})}}}

package/dist-standalone/http-compat.d.ts

@@ -147,4 +147,4 @@ export declare function createGotCompat(): {
  * const response = await fetch('https://api.example.com/data');
  * ```
  */
-export declare function wrapFetch(fetchImpl: typeof fetch): typeof xfetch;
+export declare function wrapFetch(_fetchImpl: typeof fetch): typeof xfetch;

package/dist-standalone/http-compat.js

@@ -1,267 +1 @@
-/**
- * @module http-compat
- * HTTP client compatibility adapters for xBind auto-upgrade
- *
- * Provides drop-in replacements for popular HTTP clients (fetch, axios, got)
- * that transparently upgrade to xBind when both parties support it.
- */
-import { xfetch } from './xfetch.js';
-/**
- * Create axios-compatible HTTP client with xBind auto-upgrade
- *
- * Drop-in replacement for axios that transparently upgrades to xBind.
- *
- * @returns Axios-compatible client
- *
- * @example
- * ```typescript
- * import { createAxiosCompat } from '@private.me/xbind/http-compat';
- *
- * const axios = createAxiosCompat();
- *
- * // Auto-upgrades to xBind if supported
- * const response = await axios.get('https://api.example.com/data');
- * console.log('Used xBind?', response.xbind?.used);
- * console.log('Data:', response.data);
- * ```
- */
-export function createAxiosCompat() {
-    async function request(config) {
-        // Normalize config
-        const cfg = typeof config === 'string' ? { url: config } : config;
-        const method = cfg.method?.toUpperCase() ?? 'GET';
-        const url = cfg.baseURL
-            ? new URL(cfg.url ?? '', cfg.baseURL).toString()
-            : cfg.url ?? '';
-        // Build headers
-        const headers = { ...cfg.headers };
-        // Build URL with query params
-        let finalUrl = url;
-        if (cfg.params) {
-            const params = new URLSearchParams();
-            for (const [key, value] of Object.entries(cfg.params)) {
-                params.append(key, String(value));
-            }
-            finalUrl = `${url}?${params.toString()}`;
-        }
-        // Build request body
-        let body;
-        if (cfg.data) {
-            if (typeof cfg.data === 'string') {
-                body = cfg.data;
-            }
-            else {
-                body = JSON.stringify(cfg.data);
-                headers['Content-Type'] = 'application/json';
-            }
-        }
-        // Convert to xfetch options
-        const xfetchOpts = {
-            method,
-            headers,
-            body,
-            timeout: cfg.timeout,
-            forceXBind: cfg.forceXBind,
-            disableXBind: cfg.disableXBind,
-        };
-        // Make request via xfetch
-        const response = await xfetch(finalUrl, xfetchOpts);
-        // Parse response body based on responseType
-        let data;
-        const responseType = cfg.responseType ?? 'json';
-        switch (responseType) {
-            case 'json':
-                data = (await response.json());
-                break;
-            case 'text':
-                data = (await response.text());
-                break;
-            case 'blob':
-                data = (await response.blob());
-                break;
-            case 'arraybuffer':
-                data = (await response.arrayBuffer());
-                break;
-            default:
-                data = (await response.json());
-        }
-        // Validate status if custom validator provided
-        if (cfg.validateStatus && !cfg.validateStatus(response.status)) {
-            throw new Error(`Request failed with status ${response.status}`);
-        }
-        // Convert headers to object
-        const responseHeaders = {};
-        response.headers.forEach((value, key) => {
-            responseHeaders[key] = value;
-        });
-        return {
-            data,
-            status: response.status,
-            statusText: response.statusText,
-            headers: responseHeaders,
-            config: cfg,
-            xbind: {
-                used: response.usedXBind,
-                protocol: response.transport.protocol,
-                latency: response.transport.latency,
-                peerDID: response.transport.peerDID,
-            },
-        };
-    }
-    // Convenience methods
-    async function get(url, config) {
-        return request({ ...config, url, method: 'GET' });
-    }
-    async function post(url, data, config) {
-        return request({ ...config, url, method: 'POST', data });
-    }
-    async function put(url, data, config) {
-        return request({ ...config, url, method: 'PUT', data });
-    }
-    async function patch(url, data, config) {
-        return request({ ...config, url, method: 'PATCH', data });
-    }
-    async function del(url, config) {
-        return request({ ...config, url, method: 'DELETE' });
-    }
-    return {
-        request,
-        get,
-        post,
-        put,
-        patch,
-        delete: del,
-    };
-}
-/**
- * Create got-compatible HTTP client with xBind auto-upgrade
- *
- * Drop-in replacement for got that transparently upgrades to xBind.
- *
- * @returns Got-compatible client
- *
- * @example
- * ```typescript
- * import { createGotCompat } from '@private.me/xbind/http-compat';
- *
- * const got = createGotCompat();
- *
- * // Auto-upgrades to xBind if supported
- * const response = await got('https://api.example.com/data', {
- *   responseType: 'json',
- * });
- * console.log('Used xBind?', response.xbind?.used);
- * console.log('Body:', response.body);
- * ```
- */
-export function createGotCompat() {
-    async function got(url, options) {
-        // Normalize options
-        const opts = typeof url === 'string' ? { ...options, url } : url;
-        const method = opts.method?.toUpperCase() ?? 'GET';
-        const finalUrl = opts.url ?? '';
-        // Build headers
-        const headers = { ...opts.headers };
-        // Build URL with search params
-        let urlWithParams = finalUrl;
-        if (opts.searchParams) {
-            const params = new URLSearchParams();
-            for (const [key, value] of Object.entries(opts.searchParams)) {
-                params.append(key, String(value));
-            }
-            urlWithParams = `${finalUrl}?${params.toString()}`;
-        }
-        // Build request body
-        let body;
-        if (opts.json) {
-            body = JSON.stringify(opts.json);
-            headers['Content-Type'] = 'application/json';
-        }
-        else if (opts.body) {
-            // Convert Buffer to string for compatibility with xfetch
-            // SAFETY: After instanceof check, both branches produce string type
-            body = (opts.body instanceof Buffer ? opts.body.toString() : opts.body);
-        }
-        // Extract timeout
-        const timeout = typeof opts.timeout === 'number'
-            ? opts.timeout
-            : opts.timeout?.request;
-        // Convert to xfetch options
-        const xfetchOpts = {
-            method,
-            headers,
-            body,
-            timeout,
-            forceXBind: opts.forceXBind,
-            disableXBind: opts.disableXBind,
-        };
-        // Make request via xfetch
-        const response = await xfetch(urlWithParams, xfetchOpts);
-        // Parse response body based on responseType
-        let responseBody;
-        const responseType = opts.responseType ?? 'text';
-        switch (responseType) {
-            case 'json':
-                responseBody = (await response.json());
-                break;
-            case 'text':
-                responseBody = (await response.text());
-                break;
-            case 'buffer':
-                const arrayBuffer = await response.arrayBuffer();
-                responseBody = Buffer.from(arrayBuffer);
-                break;
-            default:
-                responseBody = (await response.text());
-        }
-        // Convert headers to object
-        const responseHeaders = {};
-        response.headers.forEach((value, key) => {
-            responseHeaders[key] = value;
-        });
-        return {
-            body: responseBody,
-            statusCode: response.status,
-            headers: responseHeaders,
-            url: response.url,
-            requestUrl: urlWithParams,
-            xbind: {
-                used: response.usedXBind,
-                protocol: response.transport.protocol,
-                latency: response.transport.latency,
-                peerDID: response.transport.peerDID,
-            },
-        };
-    }
-    // Convenience methods
-    got.get = (url, options) => got(url, { ...options, method: 'GET' });
-    got.post = (url, options) => got(url, { ...options, method: 'POST' });
-    got.put = (url, options) => got(url, { ...options, method: 'PUT' });
-    got.patch = (url, options) => got(url, { ...options, method: 'PATCH' });
-    got.delete = (url, options) => got(url, { ...options, method: 'DELETE' });
-    return got;
-}
-/**
- * Wrap existing fetch implementation with xBind auto-upgrade
- *
- * Use this to upgrade an existing fetch instance (like node-fetch, cross-fetch, etc.)
- *
- * @param fetchImpl - Fetch implementation to wrap
- * @returns Wrapped fetch with xBind support
- *
- * @example
- * ```typescript
- * import { wrapFetch } from '@private.me/xbind/http-compat';
- * import nodeFetch from 'node-fetch';
- *
- * const fetch = wrapFetch(nodeFetch);
- *
- * // Uses xBind if supported, falls back to node-fetch
- * const response = await fetch('https://api.example.com/data');
- * ```
- */
-export function wrapFetch(fetchImpl) {
-    // Return xfetch (which already handles auto-upgrade and fallback)
-    // The original fetchImpl is not used because xfetch uses global fetch
-    return xfetch;
-}
+import{xfetch}from"./xfetch.js";export function createAxiosCompat(){async function t(t){const e="string"==typeof t?{url:t}:t,a=e.method?.toUpperCase()??"GET",r=e.baseURL?new URL(e.url??"",e.baseURL).toString():e.url??"",o={...e.headers};let n,s=r;if(e.params){const t=new URLSearchParams;for(const[a,r]of Object.entries(e.params))t.append(a,String(r));s=`${r}?${t.toString()}`}e.data&&("string"==typeof e.data?n=e.data:(n=JSON.stringify(e.data),o["Content-Type"]="application/json"));const i={method:a,headers:o,body:n,timeout:e.timeout,forceXBind:e.forceXBind,disableXBind:e.disableXBind},c=await xfetch(s,i);let u;switch(e.responseType??"json"){case"json":default:u=await c.json();break;case"text":u=await c.text();break;case"blob":u=await c.blob();break;case"arraybuffer":u=await c.arrayBuffer()}if(e.validateStatus&&!e.validateStatus(c.status))throw new Error(`Request failed with status ${c.status}`);const d={};return c.headers.forEach((t,e)=>{d[e]=t}),{data:u,status:c.status,statusText:c.statusText,headers:d,config:e,xbind:{used:c.usedXBind,protocol:c.transport.protocol,latency:c.transport.latency,peerDID:c.transport.peerDID}}}return{request:t,get:async function(e,a){return t({...a,url:e,method:"GET"})},post:async function(e,a,r){return t({...r,url:e,method:"POST",data:a})},put:async function(e,a,r){return t({...r,url:e,method:"PUT",data:a})},patch:async function(e,a,r){return t({...r,url:e,method:"PATCH",data:a})},delete:async function(e,a){return t({...a,url:e,method:"DELETE"})}}}export function createGotCompat(){async function t(t,e){const a="string"==typeof t?{...e,url:t}:t,r=a.method?.toUpperCase()??"GET",o=a.url??"",n={...a.headers};let s,i=o;if(a.searchParams){const t=new URLSearchParams;for(const[e,r]of Object.entries(a.searchParams))t.append(e,String(r));i=`${o}?${t.toString()}`}a.json?(s=JSON.stringify(a.json),n["Content-Type"]="application/json"):a.body&&(s=a.body instanceof Buffer?a.body.toString():a.body);const c={method:r,headers:n,body:s,timeout:"number"==typeof a.timeout?a.timeout:a.timeout?.request,forceXBind:a.forceXBind,disableXBind:a.disableXBind},u=await xfetch(i,c);let d;switch(a.responseType??"text"){case"json":d=await u.json();break;case"text":default:d=await u.text();break;case"buffer":{const t=await u.arrayBuffer();d=Buffer.from(t);break}}const f={};return u.headers.forEach((t,e)=>{f[e]=t}),{body:d,statusCode:u.status,headers:f,url:u.url,requestUrl:i,xbind:{used:u.usedXBind,protocol:u.transport.protocol,latency:u.transport.latency,peerDID:u.transport.peerDID}}}return t.get=(e,a)=>t(e,{...a,method:"GET"}),t.post=(e,a)=>t(e,{...a,method:"POST"}),t.put=(e,a)=>t(e,{...a,method:"PUT"}),t.patch=(e,a)=>t(e,{...a,method:"PATCH"}),t.delete=(e,a)=>t(e,{...a,method:"DELETE"}),t}export function wrapFetch(){return xfetch}