@gethashd/bytecave-browser 1.0.61 → 1.0.64

package/dist/{chunk-IIXRZSDW.js → chunk-CKGWAOU6.js}

@@ -4127,7 +4127,7 @@ function calcWOpts(W, scalarBits) {
   const shiftBy = BigInt(W);
   return { windows, windowSize, mask, maxNumber, shiftBy };
 }
-function calcOffsets(n, window, wOpts) {
+function calcOffsets(n, window2, wOpts) {
   const { windowSize, mask, maxNumber, shiftBy } = wOpts;
   let wbits = Number(n & mask);
   let nextN = n >> shiftBy;
@@ -4135,11 +4135,11 @@ function calcOffsets(n, window, wOpts) {
     wbits -= maxNumber;
     nextN += _1n3;
   }
-  const offsetStart = window * windowSize;
+  const offsetStart = window2 * windowSize;
   const offset = offsetStart + Math.abs(wbits) - 1;
   const isZero = wbits === 0;
   const isNeg = wbits < 0;
-  const isNegF = window % 2 !== 0;
+  const isNegF = window2 % 2 !== 0;
   const offsetF = offsetStart;
   return { nextN, offset, isZero, isNeg, isNegF, offsetF };
 }
@@ -4192,7 +4192,7 @@ var wNAF = class {
     const points = [];
     let p = point;
     let base2 = p;
-    for (let window = 0; window < windows; window++) {
+    for (let window2 = 0; window2 < windows; window2++) {
       base2 = p;
       points.push(base2);
       for (let i = 1; i < windowSize; i++) {
@@ -4215,8 +4215,8 @@ var wNAF = class {
     let p = this.ZERO;
     let f = this.BASE;
     const wo = calcWOpts(W, this.bits);
-    for (let window = 0; window < wo.windows; window++) {
-      const { nextN, offset, isZero, isNeg, isNegF, offsetF } = calcOffsets(n, window, wo);
+    for (let window2 = 0; window2 < wo.windows; window2++) {
+      const { nextN, offset, isZero, isNeg, isNegF, offsetF } = calcOffsets(n, window2, wo);
       n = nextN;
       if (isZero) {
         f = f.add(negateCt(isNegF, precomputes[offsetF]));
@@ -4234,10 +4234,10 @@ var wNAF = class {
    */
   wNAFUnsafe(W, precomputes, n, acc = this.ZERO) {
     const wo = calcWOpts(W, this.bits);
-    for (let window = 0; window < wo.windows; window++) {
+    for (let window2 = 0; window2 < wo.windows; window2++) {
       if (n === _0n3)
         break;
-      const { nextN, offset, isZero, isNeg } = calcOffsets(n, window, wo);
+      const { nextN, offset, isZero, isNeg } = calcOffsets(n, window2, wo);
       n = nextN;
       if (isZero) {
         continue;
@@ -6181,10 +6181,15 @@ var StorageWebSocketClient = class {
     if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
       await this.connect();
     }
+    const connectionTimeout = 5e3;
+    const startTime = Date.now();
+    while ((!this.ws || this.ws.readyState !== WebSocket.OPEN) && Date.now() - startTime < connectionTimeout) {
+      await new Promise((resolve) => setTimeout(resolve, 50));
+    }
     if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
       return {
         success: false,
-        error: "WebSocket not connected after connect() call"
+        error: "WebSocket connection timeout"
       };
     }
     const requestId = Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
@@ -7117,6 +7122,16 @@ function ByteCaveProvider({
     getNodeHealth,
     error
   };
+  useEffect(() => {
+    window.__BYTECAVE_CONTEXT__ = {
+      retrieve,
+      store,
+      isConnected: connectionState === "connected"
+    };
+    return () => {
+      delete window.__BYTECAVE_CONTEXT__;
+    };
+  }, [retrieve, store, connectionState]);
   return /* @__PURE__ */ React.createElement(ByteCaveContext.Provider, { value }, children);
 }
 function useByteCaveContext() {
@@ -7366,25 +7381,43 @@ function useHashdUrl(hashdUrl) {
     }
     const cid = hashdUrl.replace("hashd://", "").split("?")[0];
     let mounted = true;
+    let retryCount = 0;
+    const maxRetries = 3;
+    const retryDelay = 1e3;
     setLoading(true);
     setError(null);
-    retrieve(cid).then((result) => {
-      if (!mounted) return;
-      if (result.success && result.data) {
-        const dataCopy = new Uint8Array(result.data);
-        const blob = new Blob([dataCopy]);
-        const url = URL.createObjectURL(blob);
-        setBlobUrl(url);
-        setLoading(false);
-      } else {
-        setError(result.error || "Failed to retrieve content");
-        setLoading(false);
-      }
-    }).catch((err) => {
-      if (!mounted) return;
-      setError(err.message || "Failed to retrieve content");
-      setLoading(false);
-    });
+    const attemptRetrieve = () => {
+      retrieve(cid).then((result) => {
+        if (!mounted) return;
+        if (result.success && result.data) {
+          const dataCopy = new Uint8Array(result.data);
+          const blob = new Blob([dataCopy]);
+          const url = URL.createObjectURL(blob);
+          setBlobUrl(url);
+          setLoading(false);
+        } else {
+          if (retryCount < maxRetries && result.error?.includes("not connected")) {
+            retryCount++;
+            console.log(`[useHashdUrl] Retry ${retryCount}/${maxRetries} for CID:`, cid.slice(0, 12));
+            setTimeout(attemptRetrieve, retryDelay);
+          } else {
+            setError(result.error || "Failed to retrieve content");
+            setLoading(false);
+          }
+        }
+      }).catch((err) => {
+        if (!mounted) return;
+        if (retryCount < maxRetries && err.message?.includes("not connected")) {
+          retryCount++;
+          console.log(`[useHashdUrl] Retry ${retryCount}/${maxRetries} for CID:`, cid.slice(0, 12));
+          setTimeout(attemptRetrieve, retryDelay);
+        } else {
+          setError(err.message || "Failed to retrieve content");
+          setLoading(false);
+        }
+      });
+    };
+    attemptRetrieve();
     return () => {
       mounted = false;
       if (blobUrl) {

package/dist/index.cjs

@@ -4195,7 +4195,7 @@ function calcWOpts(W, scalarBits) {
   const shiftBy = BigInt(W);
   return { windows, windowSize, mask, maxNumber, shiftBy };
 }
-function calcOffsets(n, window, wOpts) {
+function calcOffsets(n, window2, wOpts) {
   const { windowSize, mask, maxNumber, shiftBy } = wOpts;
   let wbits = Number(n & mask);
   let nextN = n >> shiftBy;
@@ -4203,11 +4203,11 @@ function calcOffsets(n, window, wOpts) {
     wbits -= maxNumber;
     nextN += _1n3;
   }
-  const offsetStart = window * windowSize;
+  const offsetStart = window2 * windowSize;
   const offset = offsetStart + Math.abs(wbits) - 1;
   const isZero = wbits === 0;
   const isNeg = wbits < 0;
-  const isNegF = window % 2 !== 0;
+  const isNegF = window2 % 2 !== 0;
   const offsetF = offsetStart;
   return { nextN, offset, isZero, isNeg, isNegF, offsetF };
 }
@@ -4260,7 +4260,7 @@ var wNAF = class {
     const points = [];
     let p = point;
     let base2 = p;
-    for (let window = 0; window < windows; window++) {
+    for (let window2 = 0; window2 < windows; window2++) {
       base2 = p;
       points.push(base2);
       for (let i = 1; i < windowSize; i++) {
@@ -4283,8 +4283,8 @@ var wNAF = class {
     let p = this.ZERO;
     let f = this.BASE;
     const wo = calcWOpts(W, this.bits);
-    for (let window = 0; window < wo.windows; window++) {
-      const { nextN, offset, isZero, isNeg, isNegF, offsetF } = calcOffsets(n, window, wo);
+    for (let window2 = 0; window2 < wo.windows; window2++) {
+      const { nextN, offset, isZero, isNeg, isNegF, offsetF } = calcOffsets(n, window2, wo);
       n = nextN;
       if (isZero) {
         f = f.add(negateCt(isNegF, precomputes[offsetF]));
@@ -4302,10 +4302,10 @@ var wNAF = class {
    */
   wNAFUnsafe(W, precomputes, n, acc = this.ZERO) {
     const wo = calcWOpts(W, this.bits);
-    for (let window = 0; window < wo.windows; window++) {
+    for (let window2 = 0; window2 < wo.windows; window2++) {
       if (n === _0n3)
         break;
-      const { nextN, offset, isZero, isNeg } = calcOffsets(n, window, wo);
+      const { nextN, offset, isZero, isNeg } = calcOffsets(n, window2, wo);
       n = nextN;
       if (isZero) {
         continue;
@@ -6234,10 +6234,15 @@ var StorageWebSocketClient = class {
     if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
       await this.connect();
     }
+    const connectionTimeout = 5e3;
+    const startTime = Date.now();
+    while ((!this.ws || this.ws.readyState !== WebSocket.OPEN) && Date.now() - startTime < connectionTimeout) {
+      await new Promise((resolve) => setTimeout(resolve, 50));
+    }
     if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
       return {
         success: false,
-        error: "WebSocket not connected after connect() call"
+        error: "WebSocket connection timeout"
       };
     }
     const requestId = Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
@@ -7170,6 +7175,16 @@ function ByteCaveProvider({
     getNodeHealth,
     error
   };
+  (0, import_react.useEffect)(() => {
+    window.__BYTECAVE_CONTEXT__ = {
+      retrieve,
+      store,
+      isConnected: connectionState === "connected"
+    };
+    return () => {
+      delete window.__BYTECAVE_CONTEXT__;
+    };
+  }, [retrieve, store, connectionState]);
   return /* @__PURE__ */ import_react.default.createElement(ByteCaveContext.Provider, { value }, children);
 }
 function useByteCaveContext() {
@@ -7561,25 +7576,43 @@ function useHashdUrl(hashdUrl) {
     }
     const cid = hashdUrl.replace("hashd://", "").split("?")[0];
     let mounted = true;
+    let retryCount = 0;
+    const maxRetries = 3;
+    const retryDelay = 1e3;
     setLoading(true);
     setError(null);
-    retrieve(cid).then((result) => {
-      if (!mounted) return;
-      if (result.success && result.data) {
-        const dataCopy = new Uint8Array(result.data);
-        const blob = new Blob([dataCopy]);
-        const url = URL.createObjectURL(blob);
-        setBlobUrl(url);
-        setLoading(false);
-      } else {
-        setError(result.error || "Failed to retrieve content");
-        setLoading(false);
-      }
-    }).catch((err) => {
-      if (!mounted) return;
-      setError(err.message || "Failed to retrieve content");
-      setLoading(false);
-    });
+    const attemptRetrieve = () => {
+      retrieve(cid).then((result) => {
+        if (!mounted) return;
+        if (result.success && result.data) {
+          const dataCopy = new Uint8Array(result.data);
+          const blob = new Blob([dataCopy]);
+          const url = URL.createObjectURL(blob);
+          setBlobUrl(url);
+          setLoading(false);
+        } else {
+          if (retryCount < maxRetries && result.error?.includes("not connected")) {
+            retryCount++;
+            console.log(`[useHashdUrl] Retry ${retryCount}/${maxRetries} for CID:`, cid.slice(0, 12));
+            setTimeout(attemptRetrieve, retryDelay);
+          } else {
+            setError(result.error || "Failed to retrieve content");
+            setLoading(false);
+          }
+        }
+      }).catch((err) => {
+        if (!mounted) return;
+        if (retryCount < maxRetries && err.message?.includes("not connected")) {
+          retryCount++;
+          console.log(`[useHashdUrl] Retry ${retryCount}/${maxRetries} for CID:`, cid.slice(0, 12));
+          setTimeout(attemptRetrieve, retryDelay);
+        } else {
+          setError(err.message || "Failed to retrieve content");
+          setLoading(false);
+        }
+      });
+    };
+    attemptRetrieve();
     return () => {
       mounted = false;
       if (blobUrl) {

package/dist/index.js

@@ -13,7 +13,7 @@ import {
   useHashdImage,
   useHashdMedia,
   useHashdUrl
-} from "./chunk-IIXRZSDW.js";
+} from "./chunk-CKGWAOU6.js";
 import {
   clearHashdCache,
   createHashdUrl,

package/dist/react/index.cjs

@@ -4450,7 +4450,7 @@ function calcWOpts(W, scalarBits) {
   const shiftBy = BigInt(W);
   return { windows, windowSize, mask, maxNumber, shiftBy };
 }
-function calcOffsets(n, window, wOpts) {
+function calcOffsets(n, window2, wOpts) {
   const { windowSize, mask, maxNumber, shiftBy } = wOpts;
   let wbits = Number(n & mask);
   let nextN = n >> shiftBy;
@@ -4458,11 +4458,11 @@ function calcOffsets(n, window, wOpts) {
     wbits -= maxNumber;
     nextN += _1n3;
   }
-  const offsetStart = window * windowSize;
+  const offsetStart = window2 * windowSize;
   const offset = offsetStart + Math.abs(wbits) - 1;
   const isZero = wbits === 0;
   const isNeg = wbits < 0;
-  const isNegF = window % 2 !== 0;
+  const isNegF = window2 % 2 !== 0;
   const offsetF = offsetStart;
   return { nextN, offset, isZero, isNeg, isNegF, offsetF };
 }
@@ -4515,7 +4515,7 @@ var wNAF = class {
     const points = [];
     let p = point;
     let base2 = p;
-    for (let window = 0; window < windows; window++) {
+    for (let window2 = 0; window2 < windows; window2++) {
       base2 = p;
       points.push(base2);
       for (let i = 1; i < windowSize; i++) {
@@ -4538,8 +4538,8 @@ var wNAF = class {
     let p = this.ZERO;
     let f = this.BASE;
     const wo = calcWOpts(W, this.bits);
-    for (let window = 0; window < wo.windows; window++) {
-      const { nextN, offset, isZero, isNeg, isNegF, offsetF } = calcOffsets(n, window, wo);
+    for (let window2 = 0; window2 < wo.windows; window2++) {
+      const { nextN, offset, isZero, isNeg, isNegF, offsetF } = calcOffsets(n, window2, wo);
       n = nextN;
       if (isZero) {
         f = f.add(negateCt(isNegF, precomputes[offsetF]));
@@ -4557,10 +4557,10 @@ var wNAF = class {
    */
   wNAFUnsafe(W, precomputes, n, acc = this.ZERO) {
     const wo = calcWOpts(W, this.bits);
-    for (let window = 0; window < wo.windows; window++) {
+    for (let window2 = 0; window2 < wo.windows; window2++) {
       if (n === _0n3)
         break;
-      const { nextN, offset, isZero, isNeg } = calcOffsets(n, window, wo);
+      const { nextN, offset, isZero, isNeg } = calcOffsets(n, window2, wo);
       n = nextN;
       if (isZero) {
         continue;
@@ -6383,25 +6383,43 @@ function useHashdUrl(hashdUrl) {
     }
     const cid = hashdUrl.replace("hashd://", "").split("?")[0];
     let mounted = true;
+    let retryCount = 0;
+    const maxRetries = 3;
+    const retryDelay = 1e3;
     setLoading(true);
     setError(null);
-    retrieve(cid).then((result) => {
-      if (!mounted) return;
-      if (result.success && result.data) {
-        const dataCopy = new Uint8Array(result.data);
-        const blob = new Blob([dataCopy]);
-        const url = URL.createObjectURL(blob);
-        setBlobUrl(url);
-        setLoading(false);
-      } else {
-        setError(result.error || "Failed to retrieve content");
-        setLoading(false);
-      }
-    }).catch((err) => {
-      if (!mounted) return;
-      setError(err.message || "Failed to retrieve content");
-      setLoading(false);
-    });
+    const attemptRetrieve = () => {
+      retrieve(cid).then((result) => {
+        if (!mounted) return;
+        if (result.success && result.data) {
+          const dataCopy = new Uint8Array(result.data);
+          const blob = new Blob([dataCopy]);
+          const url = URL.createObjectURL(blob);
+          setBlobUrl(url);
+          setLoading(false);
+        } else {
+          if (retryCount < maxRetries && result.error?.includes("not connected")) {
+            retryCount++;
+            console.log(`[useHashdUrl] Retry ${retryCount}/${maxRetries} for CID:`, cid.slice(0, 12));
+            setTimeout(attemptRetrieve, retryDelay);
+          } else {
+            setError(result.error || "Failed to retrieve content");
+            setLoading(false);
+          }
+        }
+      }).catch((err) => {
+        if (!mounted) return;
+        if (retryCount < maxRetries && err.message?.includes("not connected")) {
+          retryCount++;
+          console.log(`[useHashdUrl] Retry ${retryCount}/${maxRetries} for CID:`, cid.slice(0, 12));
+          setTimeout(attemptRetrieve, retryDelay);
+        } else {
+          setError(err.message || "Failed to retrieve content");
+          setLoading(false);
+        }
+      });
+    };
+    attemptRetrieve();
     return () => {
       mounted = false;
       if (blobUrl) {

package/dist/react/index.js

@@ -8,7 +8,7 @@ import {
   useHashdImage,
   useHashdMedia,
   useHashdUrl
-} from "../chunk-IIXRZSDW.js";
+} from "../chunk-CKGWAOU6.js";
 import "../chunk-EEZWRIUI.js";
 export {
   HashdAudio,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gethashd/bytecave-browser",
-  "version": "1.0.61",
+  "version": "1.0.64",
   "description": "ByteCave browser client for WebRTC P2P connections to storage nodes",
   "main": "dist/index.cjs",
   "module": "dist/index.js",

package/src/provider.tsx

@@ -266,6 +266,19 @@ export function ByteCaveProvider({
     error
   };
 
+  // Expose retrieve function on window for non-React code
+  useEffect(() => {
+    (window as any).__BYTECAVE_CONTEXT__ = {
+      retrieve,
+      store,
+      isConnected: connectionState === 'connected'
+    };
+    
+    return () => {
+      delete (window as any).__BYTECAVE_CONTEXT__;
+    };
+  }, [retrieve, store, connectionState]);
+
   return (
     <ByteCaveContext.Provider value={value}>
       {children}

package/src/react/useHashdUrl.ts

@@ -32,29 +32,52 @@ export function useHashdUrl(hashdUrl: string | null | undefined): UseHashdUrlRes
     const cid = hashdUrl.replace('hashd://', '').split('?')[0];
 
     let mounted = true;
+    let retryCount = 0;
+    const maxRetries = 3;
+    const retryDelay = 1000; // 1 second between retries
+
     setLoading(true);
     setError(null);
 
-    retrieve(cid)
-      .then(result => {
-        if (!mounted) return;
+    const attemptRetrieve = () => {
+      retrieve(cid)
+        .then(result => {
+          if (!mounted) return;
+
+          if (result.success && result.data) {
+            const dataCopy = new Uint8Array(result.data);
+            const blob = new Blob([dataCopy]);
+            const url = URL.createObjectURL(blob);
+            setBlobUrl(url);
+            setLoading(false);
+          } else {
+            // Retry on failure if we haven't exceeded max retries
+            if (retryCount < maxRetries && result.error?.includes('not connected')) {
+              retryCount++;
+              console.log(`[useHashdUrl] Retry ${retryCount}/${maxRetries} for CID:`, cid.slice(0, 12));
+              setTimeout(attemptRetrieve, retryDelay);
+            } else {
+              setError(result.error || 'Failed to retrieve content');
+              setLoading(false);
+            }
+          }
+        })
+        .catch(err => {
+          if (!mounted) return;
+          
+          // Retry on connection errors
+          if (retryCount < maxRetries && err.message?.includes('not connected')) {
+            retryCount++;
+            console.log(`[useHashdUrl] Retry ${retryCount}/${maxRetries} for CID:`, cid.slice(0, 12));
+            setTimeout(attemptRetrieve, retryDelay);
+          } else {
+            setError(err.message || 'Failed to retrieve content');
+            setLoading(false);
+          }
+        });
+    };
 
-        if (result.success && result.data) {
-          const dataCopy = new Uint8Array(result.data);
-          const blob = new Blob([dataCopy]);
-          const url = URL.createObjectURL(blob);
-          setBlobUrl(url);
-          setLoading(false);
-        } else {
-          setError(result.error || 'Failed to retrieve content');
-          setLoading(false);
-        }
-      })
-      .catch(err => {
-        if (!mounted) return;
-        setError(err.message || 'Failed to retrieve content');
-        setLoading(false);
-      });
+    attemptRetrieve();
 
     return () => {
       mounted = false;

package/src/storage-websocket.ts

@@ -215,15 +215,22 @@ export class StorageWebSocketClient {
   }
 
   async retrieve(cid: string, timeout: number = 30000): Promise<{ success: boolean; data?: Uint8Array; mimeType?: string; error?: string }> {
+    // Ensure connection is established
     if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
       await this.connect();
     }
-
-    // Double-check connection state after connect() completes
+    
+    // Wait for WebSocket to be in OPEN state (with timeout)
+    const connectionTimeout = 5000; // 5 seconds max wait
+    const startTime = Date.now();
+    while ((!this.ws || this.ws.readyState !== WebSocket.OPEN) && (Date.now() - startTime < connectionTimeout)) {
+      await new Promise(resolve => setTimeout(resolve, 50));
+    }
+    
     if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
       return {
         success: false,
-        error: 'WebSocket not connected after connect() call'
+        error: 'WebSocket connection timeout'
       };
     }