@private.me/xbind 3.0.0 → 3.0.2

package/dist-standalone/health-check.js

@@ -1 +1,332 @@
-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()}]})}}}
+/**
+ * @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(),
+                    },
+                ],
+            });
+        }
+    };
+}

package/dist-standalone/http-compat.js

@@ -1 +1,267 @@
-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)}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}
+/**
+ * @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;
+}